lustre/tests/recovery-small.sh

   1 #!/bin/bash
   2
   3 set -e
   4
   5 #         bug  5493  LU2034
   6 ALWAYS_EXCEPT="52    60      $RECOVERY_SMALL_EXCEPT"
   7
   8 export MULTIOP=${MULTIOP:-multiop}
   9 PTLDEBUG=${PTLDEBUG:--1}
  10 LUSTRE=${LUSTRE:-`dirname $0`/..}
  11 . $LUSTRE/tests/test-framework.sh
  12 init_test_env $@
  13 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  14 init_logging
  15
  16 require_dsh_mds || exit 0
  17
  18 # also long tests: 19, 21a, 21e, 21f, 23, 27
  19 #                                   1  2.5  2.5    4    4          (min)"
  20 [ "$SLOW" = "no" ] && EXCEPT_SLOW="17  26a  26b    50   51     57"
  21
  22 [ $(facet_fstype $SINGLEMDS) = "zfs" ] &&
  23 # bug number for skipped test:        LU-2194 LU-2547
  24         ALWAYS_EXCEPT="$ALWAYS_EXCEPT 19b     24a 24b"
  25
  26 build_test_filter
  27
  28 # Allow us to override the setup if we already have a mounted system by
  29 # setting SETUP=" " and CLEANUP=" "
  30 SETUP=${SETUP:-""}
  31 CLEANUP=${CLEANUP:-""}
  32
  33 check_and_setup_lustre
  34
  35 assert_DIR
  36 rm -rf $DIR/d[0-9]* $DIR/f.${TESTSUITE}*
  37
  38 test_1() {
  39         local f1="$DIR/$tfile"
  40         local f2="$DIR/$tfile.2"
  41
  42         drop_request "mcreate $f1" ||
  43                 error_noexit "create '$f1': drop req"
  44
  45         drop_reint_reply "mcreate $f2" ||
  46                 error_noexit "create '$f2': drop rep"
  47
  48         drop_request "tchmod 111 $f2" ||
  49                 error_noexit "chmod '$f2': drop req"
  50
  51         drop_reint_reply "tchmod 666 $f2" ||
  52                 error_noexit "chmod '$f2': drop rep"
  53
  54         drop_request "statone $f2" ||
  55                 error_noexit "stat '$f2': drop req"
  56
  57         drop_reply  "statone $f2" ||
  58                 error_noexit "stat '$f2': drop rep"
  59 }
  60 run_test 1 "create, chmod, stat: drop req, drop rep"
  61
  62 test_4() {
  63         local t=$DIR/$tfile
  64         do_facet_create_file client $t 10K ||
  65                 error_noexit "Create file $t"
  66
  67         drop_request "cat $t > /dev/null" ||
  68                 error_noexit "Open request for $t file"
  69
  70         drop_reply "cat $t > /dev/null" ||
  71                 error_noexit "Open replay for $t file"
  72 }
  73 run_test 4 "open: drop req, drop rep"
  74
  75 test_5() {
  76         local T=$DIR/$tfile
  77         local R="$T-renamed"
  78         local RR="$T-renamed-again"
  79         do_facet_create_file client $T 10K ||
  80                 error_noexit "Create file $T"
  81
  82         drop_request "mv $T $R" ||
  83                 error_noexit "Rename $T"
  84
  85         drop_reint_reply "mv $R $RR" ||
  86                 error_noexit "Failed rename replay on $R"
  87
  88         do_facet client "checkstat -v $RR" ||
  89                 error_noexit "checkstat error on $RR"
  90
  91         do_facet client "rm $RR" ||
  92                 error_noexit "Can't remove file $RR"
  93 }
  94 run_test 5 "rename: drop req, drop rep"
  95
  96 test_6() {
  97         local T=$DIR/$tfile
  98         local LINK1=$DIR/$tfile.link1
  99         local LINK2=$DIR/$tfile.link2
 100
 101         do_facet_create_file client $T 10K ||
 102                 error_noexit "Create file $T"
 103
 104         drop_request "mlink $T $LINK1" ||
 105                 error_noexit "mlink request for $T"
 106
 107         drop_reint_reply "mlink $T $LINK2" ||
 108                 error_noexit "mlink reply for $T"
 109
 110         drop_request "munlink $LINK1" ||
 111                 error_noexit "munlink request for $T"
 112
 113         drop_reint_reply "munlink $LINK2" ||
 114                 error_noexit "munlink reply for $T"
 115
 116         do_facet client "rm $T" ||
 117                 error_noexit "Can't remove file $T"
 118 }
 119 run_test 6 "link, unlink: drop req, drop rep"
 120
 121 #bug 1423
 122 test_8() {
 123     drop_reint_reply "touch $DIR/$tfile"    || return 1
 124 }
 125 run_test 8 "touch: drop rep (bug 1423)"
 126
 127 #bug 1420
 128 test_9() {
 129         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 130
 131         local t1=${tfile}.1
 132         local t2=${tfile}.2
 133         do_facet_random_file client $TMP/$tfile 1K ||
 134                 error_noexit "Create random file $TMP/$tfile"
 135         # make this big, else test 9 doesn't wait for bulk -- bz 5595
 136         do_facet_create_file client $TMP/$t1 4M ||
 137                 error_noexit "Create file $TMP/$t1"
 138         do_facet client "cp $TMP/$t1 $DIR/$t1" ||
 139                 error_noexit "Can't copy to $DIR/$t1 file"
 140         pause_bulk "cp $TMP/$tfile $DIR/$tfile" ||
 141                 error_noexit "Can't pause_bulk copy"
 142         do_facet client "cp $TMP/$t1 $DIR/$t2" ||
 143                 error_noexit "Can't copy file"
 144         do_facet client "sync"
 145         do_facet client "rm $DIR/$tfile $DIR/$t2 $DIR/$t1" ||
 146                 error_noexit "Can't remove files"
 147         do_facet client "rm $TMP/$t1 $TMP/$tfile"
 148 }
 149 run_test 9 "pause bulk on OST (bug 1420)"
 150
 151 #bug 1521
 152 test_10() {
 153         do_facet client mcreate $DIR/$tfile ||
 154                 { error "mcreate failed: $?"; return 1; }
 155         drop_bl_callback "chmod 0777 $DIR/$tfile"  || echo "evicted as expected"
 156         # wait for the mds to evict the client
 157         #echo "sleep $(($TIMEOUT*2))"
 158         #sleep $(($TIMEOUT*2))
 159         do_facet client touch $DIR/$tfile || echo "touch failed, evicted"
 160         do_facet client checkstat -v -p 0777 $DIR/$tfile ||
 161                 { error "client checkstat failed: $?"; return 3; }
 162         do_facet client "munlink $DIR/$tfile"
 163         # allow recovery to complete
 164         client_up || client_up || sleep $TIMEOUT
 165 }
 166 run_test 10 "finish request on server after client eviction (bug 1521)"
 167
 168 #bug 2460
 169 # wake up a thread waiting for completion after eviction
 170 test_11(){
 171         do_facet client $MULTIOP $DIR/$tfile Ow  ||
 172                 { error "multiop write failed: $?"; return 1; }
 173         do_facet client $MULTIOP $DIR/$tfile or  ||
 174                 { error "multiop read failed: $?"; return 2; }
 175
 176         cancel_lru_locks osc
 177
 178         do_facet client $MULTIOP $DIR/$tfile or  ||
 179                 { error "multiop read failed: $?"; return 3; }
 180         drop_bl_callback $MULTIOP $DIR/$tfile Ow || echo "evicted as expected"
 181
 182         do_facet client munlink $DIR/$tfile ||
 183                 { error "munlink failed: $?"; return 4; }
 184         # allow recovery to complete
 185         client_up || client_up || sleep $TIMEOUT
 186 }
 187 run_test 11 "wake up a thread waiting for completion after eviction (b=2460)"
 188
 189 #b=2494
 190 test_12(){
 191         $LCTL mark $MULTIOP $DIR/$tfile OS_c
 192         do_facet $SINGLEMDS "lctl set_param fail_loc=0x115"
 193         clear_failloc $SINGLEMDS $((TIMEOUT * 2)) &
 194         multiop_bg_pause $DIR/$tfile OS_c ||
 195                 { error "multiop failed: $?"; return 1; }
 196         PID=$!
 197 #define OBD_FAIL_MDS_CLOSE_NET           0x115
 198         kill -USR1 $PID
 199         echo "waiting for multiop $PID"
 200         wait $PID || { error "wait for multiop faile: $?"; return 2; }
 201         do_facet client munlink $DIR/$tfile ||
 202                 { error "client munlink failed: $?"; return 3; }
 203         # allow recovery to complete
 204         client_up || client_up || sleep $TIMEOUT
 205 }
 206 run_test 12 "recover from timed out resend in ptlrpcd (b=2494)"
 207
 208 # Bug 113, check that readdir lost recv timeout works.
 209 test_13() {
 210         mkdir -p $DIR/$tdir || { error "mkdir failed: $?"; return 1; }
 211         touch $DIR/$tdir/newentry || { error "touch failed: $?"; return 2; }
 212 # OBD_FAIL_MDS_READPAGE_NET|OBD_FAIL_ONCE
 213         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000104"
 214         ls $DIR/$tdir || { error "ls failed: $?"; return 3; }
 215         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 216         rm -rf $DIR/$tdir || { error "remove test dir failed: $?"; return 4; }
 217 }
 218 run_test 13 "mdc_readpage restart test (bug 1138)"
 219
 220 # Bug 113, check that readdir lost send timeout works.
 221 test_14() {
 222     mkdir -p $DIR/$tdir
 223     touch $DIR/$tdir/newentry
 224 # OBD_FAIL_MDS_SENDPAGE|OBD_FAIL_ONCE
 225     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000106"
 226     ls $DIR/$tdir || return 1
 227     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 228 }
 229 run_test 14 "mdc_readpage resend test (bug 1138)"
 230
 231 test_15() {
 232     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000128"
 233     touch $DIR/$tfile && return 1
 234     return 0
 235 }
 236 run_test 15 "failed open (-ENOMEM)"
 237
 238 READ_AHEAD=`lctl get_param -n llite.*.max_read_ahead_mb | head -n 1`
 239 stop_read_ahead() {
 240    lctl set_param -n llite.*.max_read_ahead_mb 0
 241 }
 242
 243 start_read_ahead() {
 244    lctl set_param -n llite.*.max_read_ahead_mb $READ_AHEAD
 245 }
 246
 247 test_16() {
 248         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 249
 250         do_facet_random_file client $TMP/$tfile 100K ||
 251                 { error_noexit "Create random file $TMP/$T" ; return 0; }
 252         do_facet client "cp $TMP/$tfile $DIR/$tfile" ||
 253                 { error_noexit "Copy to $DIR/$tfile file" ; return 0; }
 254         sync
 255         stop_read_ahead
 256
 257 #define OBD_FAIL_PTLRPC_BULK_PUT_NET 0x504 | OBD_FAIL_ONCE
 258         do_facet ost1 "lctl set_param fail_loc=0x80000504"
 259         cancel_lru_locks osc
 260         # OST bulk will time out here, client resends
 261         do_facet client "cmp $TMP/$tfile $DIR/$tfile" || return 1
 262         do_facet ost1 lctl set_param fail_loc=0
 263         # give recovery a chance to finish (shouldn't take long)
 264         sleep $TIMEOUT
 265         do_facet client "cmp $TMP/$tfile $DIR/$tfile" || return 2
 266         start_read_ahead
 267         rm -f $TMP/$tfile
 268 }
 269 run_test 16 "timeout bulk put, don't evict client (2732)"
 270
 271 test_17() {
 272     local at_max_saved=0
 273
 274     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 275
 276         local SAMPLE_FILE=$TMP/$tfile
 277         do_facet_random_file client $SAMPLE_FILE 20K ||
 278                 { error_noexit "Create random file $SAMPLE_FILE" ; return 0; }
 279
 280     # With adaptive timeouts, bulk_get won't expire until adaptive_timeout_max
 281     if at_is_enabled; then
 282         at_max_saved=$(at_max_get ost1)
 283         at_max_set $TIMEOUT ost1
 284     fi
 285
 286     # OBD_FAIL_PTLRPC_BULK_GET_NET 0x0503 | OBD_FAIL_ONCE
 287     # OST bulk will time out here, client retries
 288     do_facet ost1 lctl set_param fail_loc=0x80000503
 289     # need to ensure we send an RPC
 290     do_facet client cp $SAMPLE_FILE $DIR/$tfile
 291     sync
 292
 293     # with AT, client will wait adaptive_max*factor+net_latency before
 294     # expiring the req, hopefully timeout*2 is enough
 295     sleep $(($TIMEOUT*2))
 296
 297     do_facet ost1 lctl set_param fail_loc=0
 298     do_facet client "df $DIR"
 299     # expect cmp to succeed, client resent bulk
 300     do_facet client "cmp $SAMPLE_FILE $DIR/$tfile" || return 3
 301     do_facet client "rm $DIR/$tfile" || return 4
 302     [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved ost1
 303     return 0
 304 }
 305 run_test 17 "timeout bulk get, don't evict client (2732)"
 306
 307 test_18a() {
 308     [ -z ${ost2_svc} ] && skip_env "needs 2 osts" && return 0
 309
 310         do_facet_create_file client $TMP/$tfile 20K ||
 311                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
 312
 313     do_facet client mkdir -p $DIR/$tdir
 314     f=$DIR/$tdir/$tfile
 315
 316     cancel_lru_locks osc
 317     pgcache_empty || return 1
 318
 319     # 1 stripe on ost2
 320     $LFS setstripe -i 1 -c 1 $f
 321     stripe_index=$($LFS getstripe -i $f)
 322     if [ $stripe_index -ne 1 ]; then
 323         $LFS getstripe $f
 324         error "$f: stripe_index $stripe_index != 1" && return
 325     fi
 326
 327     do_facet client cp $TMP/$tfile $f
 328     sync
 329     local osc2dev=`lctl get_param -n devices | grep ${ost2_svc}-osc- | egrep -v 'MDT' | awk '{print $1}'`
 330     $LCTL --device $osc2dev deactivate || return 3
 331     # my understanding is that there should be nothing in the page
 332     # cache after the client reconnects?
 333     rc=0
 334     pgcache_empty || rc=2
 335     $LCTL --device $osc2dev activate
 336     rm -f $f $TMP/$tfile
 337     return $rc
 338 }
 339 run_test 18a "manual ost invalidate clears page cache immediately"
 340
 341 test_18b() {
 342     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 343
 344         do_facet_create_file client $TMP/$tfile 20K ||
 345                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
 346
 347     do_facet client mkdir -p $DIR/$tdir
 348     f=$DIR/$tdir/$tfile
 349
 350     cancel_lru_locks osc
 351     pgcache_empty || return 1
 352
 353     $LFS setstripe -i 0 -c 1 $f
 354     stripe_index=$($LFS getstripe -i $f)
 355     if [ $stripe_index -ne 0 ]; then
 356         $LFS getstripe $f
 357         error "$f: stripe_index $stripe_index != 0" && return
 358     fi
 359
 360     do_facet client cp $TMP/$tfile $f
 361     sync
 362     ost_evict_client
 363     # allow recovery to complete
 364     sleep $((TIMEOUT + 2))
 365     # my understanding is that there should be nothing in the page
 366     # cache after the client reconnects?
 367     rc=0
 368     pgcache_empty || rc=2
 369     rm -f $f $TMP/$tfile
 370     return $rc
 371 }
 372 run_test 18b "eviction and reconnect clears page cache (2766)"
 373
 374 test_18c() {
 375     remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 376
 377         do_facet_create_file client $TMP/$tfile 20K ||
 378                 { error_noexit "Create file $TMP/$tfile" ; return 0; }
 379
 380     do_facet client mkdir -p $DIR/$tdir
 381     f=$DIR/$tdir/$tfile
 382
 383     cancel_lru_locks osc
 384     pgcache_empty || return 1
 385
 386     $LFS setstripe -i 0 -c 1 $f
 387     stripe_index=$($LFS getstripe -i $f)
 388     if [ $stripe_index -ne 0 ]; then
 389         $LFS getstripe $f
 390         error "$f: stripe_index $stripe_index != 0" && return
 391     fi
 392
 393     do_facet client cp $TMP/$tfile $f
 394     sync
 395     ost_evict_client
 396
 397     # OBD_FAIL_OST_CONNECT_NET2
 398     # lost reply to connect request
 399     do_facet ost1 lctl set_param fail_loc=0x80000225
 400     # force reconnect
 401     sleep 1
 402     df $MOUNT > /dev/null 2>&1
 403     sleep 2
 404     # my understanding is that there should be nothing in the page
 405     # cache after the client reconnects?
 406     rc=0
 407     pgcache_empty || rc=2
 408     rm -f $f $TMP/$tfile
 409     return $rc
 410 }
 411 run_test 18c "Dropped connect reply after eviction handing (14755)"
 412
 413 test_19a() {
 414         local BEFORE=`date +%s`
 415         local EVICT
 416
 417         mount_client $DIR2 || error "failed to mount $DIR2"
 418
 419         # cancel cached locks from OST to avoid eviction from it
 420         cancel_lru_locks osc
 421
 422         do_facet client "stat $DIR > /dev/null"  ||
 423                 error "failed to stat $DIR: $?"
 424         drop_ldlm_cancel "chmod 0777 $DIR2" ||
 425                 error "failed to chmod $DIR2"
 426
 427         umount_client $DIR2
 428
 429         # let the client reconnect
 430         client_reconnect
 431         EVICT=$(do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state | \
 432             awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
 433
 434         [ ! -z "$EVICT" ] && [[ $EVICT -gt $BEFORE ]] ||
 435                 (do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state;
 436                     error "no eviction: $EVICT before:$BEFORE")
 437 }
 438 run_test 19a "test expired_lock_main on mds (2867)"
 439
 440 test_19b() {
 441         local BEFORE=`date +%s`
 442         local EVICT
 443
 444         mount_client $DIR2 || error "failed to mount $DIR2: $?"
 445
 446         # cancel cached locks from MDT to avoid eviction from it
 447         cancel_lru_locks mdc
 448
 449         do_facet client $MULTIOP $DIR/$tfile Ow ||
 450                 error "failed to run multiop: $?"
 451         drop_ldlm_cancel $MULTIOP $DIR2/$tfile Ow ||
 452                 error "failed to ldlm_cancel: $?"
 453
 454         umount_client $DIR2 || error "failed to unmount $DIR2: $?"
 455         do_facet client munlink $DIR/$tfile ||
 456                 error "failed to unlink $DIR/$tfile: $?"
 457
 458         # let the client reconnect
 459         client_reconnect
 460         EVICT=$(do_facet client $LCTL get_param osc.$FSNAME-OST*.state | \
 461             awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
 462
 463         [ ! -z "$EVICT" ] && [[ $EVICT -gt $BEFORE ]] ||
 464                 (do_facet client $LCTL get_param osc.$FSNAME-OST*.state;
 465                     error "no eviction: $EVICT before:$BEFORE")
 466 }
 467 run_test 19b "test expired_lock_main on ost (2867)"
 468
 469 test_19c() {
 470         local BEFORE=`date +%s`
 471
 472         mount_client $DIR2
 473         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=0
 474
 475         mkdir -p $DIR1/$tfile
 476         stat $DIR1/$tfile
 477
 478 #define OBD_FAIL_PTLRPC_CANCEL_RESEND 0x516
 479         do_facet mds $LCTL set_param fail_loc=0x80000516
 480
 481         touch $DIR2/$tfile/file1 &
 482         PID1=$!
 483         # let touch to get blocked on the server
 484         sleep 2
 485
 486         wait $PID1
 487         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=1
 488         umount_client $DIR2
 489
 490         # let the client reconnect
 491         sleep 5
 492         EVICT=$(do_facet client $LCTL get_param mdc.$FSNAME-MDT*.state |
 493            awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
 494
 495         [ -z "$EVICT" ] || [[ $EVICT -le $BEFORE ]] || error "eviction happened"
 496 }
 497 run_test 19c "check reconnect and lock resend do not trigger expired_lock_main"
 498
 499 test_20a() {    # bug 2983 - ldlm_handle_enqueue cleanup
 500         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 501
 502         mkdir -p $DIR/$tdir
 503         $LFS setstripe -i 0 -c 1 $DIR/$tdir/${tfile}
 504         multiop_bg_pause $DIR/$tdir/${tfile} O_wc || return 1
 505         MULTI_PID=$!
 506         cancel_lru_locks osc
 507 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
 508         do_facet ost1 lctl set_param fail_loc=0x80000308
 509         kill -USR1 $MULTI_PID
 510         wait $MULTI_PID
 511         rc=$?
 512         [ $rc -eq 0 ] && error "multiop didn't fail enqueue: rc $rc" || true
 513 }
 514 run_test 20a "ldlm_handle_enqueue error (should return error)"
 515
 516 test_20b() {    # bug 2986 - ldlm_handle_enqueue error during open
 517         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 518
 519         mkdir -p $DIR/$tdir
 520         $LFS setstripe -i 0 -c 1 $DIR/$tdir/${tfile}
 521         cancel_lru_locks osc
 522 #define OBD_FAIL_LDLM_ENQUEUE_EXTENT_ERR 0x308
 523         do_facet ost1 lctl set_param fail_loc=0x80000308
 524         dd if=/etc/hosts of=$DIR/$tdir/$tfile && \
 525                 error "didn't fail open enqueue" || true
 526 }
 527 run_test 20b "ldlm_handle_enqueue error (should return error)"
 528
 529 test_21a() {
 530        mkdir -p $DIR/$tdir-1
 531        mkdir -p $DIR/$tdir-2
 532        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 533        close_pid=$!
 534
 535        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
 536        $MULTIOP $DIR/$tdir-2/f Oc &
 537        open_pid=$!
 538        sleep 1
 539        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 540
 541        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
 542        kill -USR1 $close_pid
 543        cancel_lru_locks mdc
 544        wait $close_pid || return 1
 545        wait $open_pid || return 2
 546        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 547
 548        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
 549        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
 550
 551        rm -rf $DIR/$tdir-*
 552 }
 553 run_test 21a "drop close request while close and open are both in flight"
 554
 555 test_21b() {
 556        mkdir -p $DIR/$tdir-1
 557        mkdir -p $DIR/$tdir-2
 558        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 559        close_pid=$!
 560
 561        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
 562        mcreate $DIR/$tdir-2/f &
 563        open_pid=$!
 564        sleep 1
 565        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 566
 567        kill -USR1 $close_pid
 568        cancel_lru_locks mdc
 569        wait $close_pid || return 1
 570        wait $open_pid || return 3
 571
 572        $CHECKSTAT -t file $DIR/$tdir-1/f || return 4
 573        $CHECKSTAT -t file $DIR/$tdir-2/f || return 5
 574        rm -rf $DIR/$tdir-*
 575 }
 576 run_test 21b "drop open request while close and open are both in flight"
 577
 578 test_21c() {
 579        mkdir -p $DIR/$tdir-1
 580        mkdir -p $DIR/$tdir-2
 581        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 582        close_pid=$!
 583
 584        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
 585        mcreate $DIR/$tdir-2/f &
 586        open_pid=$!
 587        sleep 3
 588        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 589
 590        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
 591        kill -USR1 $close_pid
 592        cancel_lru_locks mdc
 593        wait $close_pid || return 1
 594        wait $open_pid || return 2
 595
 596        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 597
 598        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
 599        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
 600        rm -rf $DIR/$tdir-*
 601 }
 602 run_test 21c "drop both request while close and open are both in flight"
 603
 604 test_21d() {
 605        mkdir -p $DIR/$tdir-1
 606        mkdir -p $DIR/$tdir-2
 607        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 608        pid=$!
 609
 610        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000129"
 611        $MULTIOP $DIR/$tdir-2/f Oc &
 612        sleep 1
 613        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 614
 615        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
 616        kill -USR1 $pid
 617        cancel_lru_locks mdc
 618        wait $pid || return 1
 619        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 620
 621        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
 622        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
 623
 624        rm -rf $DIR/$tdir-*
 625 }
 626 run_test 21d "drop close reply while close and open are both in flight"
 627
 628 test_21e() {
 629        mkdir -p $DIR/$tdir-1
 630        mkdir -p $DIR/$tdir-2
 631        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 632        pid=$!
 633
 634        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
 635        touch $DIR/$tdir-2/f &
 636        sleep 1
 637        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 638
 639        kill -USR1 $pid
 640        cancel_lru_locks mdc
 641        wait $pid || return 1
 642
 643        sleep $TIMEOUT
 644        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
 645        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
 646        rm -rf $DIR/$tdir-*
 647 }
 648 run_test 21e "drop open reply while close and open are both in flight"
 649
 650 test_21f() {
 651        mkdir -p $DIR/$tdir-1
 652        mkdir -p $DIR/$tdir-2
 653        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 654        pid=$!
 655
 656        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
 657        touch $DIR/$tdir-2/f &
 658        sleep 1
 659        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 660
 661        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
 662        kill -USR1 $pid
 663        cancel_lru_locks mdc
 664        wait $pid || return 1
 665        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 666
 667        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
 668        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
 669        rm -rf $DIR/$tdir-*
 670 }
 671 run_test 21f "drop both reply while close and open are both in flight"
 672
 673 test_21g() {
 674        mkdir -p $DIR/$tdir-1
 675        mkdir -p $DIR/$tdir-2
 676        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 677        pid=$!
 678
 679        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000119"
 680        touch $DIR/$tdir-2/f &
 681        sleep 1
 682        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 683
 684        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
 685        kill -USR1 $pid
 686        cancel_lru_locks mdc
 687        wait $pid || return 1
 688        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 689
 690        $CHECKSTAT -t file $DIR/$tdir-1/f || return 2
 691        $CHECKSTAT -t file $DIR/$tdir-2/f || return 3
 692        rm -rf $DIR/$tdir-*
 693 }
 694 run_test 21g "drop open reply and close request while close and open are both in flight"
 695
 696 test_21h() {
 697        mkdir -p $DIR/$tdir-1
 698        mkdir -p $DIR/$tdir-2
 699        multiop_bg_pause $DIR/$tdir-1/f O_c || return 1
 700        pid=$!
 701
 702        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000107"
 703        touch $DIR/$tdir-2/f &
 704        touch_pid=$!
 705        sleep 1
 706        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 707
 708        do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000122"
 709        cancel_lru_locks mdc
 710        kill -USR1 $pid
 711        wait $pid || return 1
 712        do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 713
 714        wait $touch_pid || return 2
 715
 716        $CHECKSTAT -t file $DIR/$tdir-1/f || return 3
 717        $CHECKSTAT -t file $DIR/$tdir-2/f || return 4
 718        rm -rf $DIR/$tdir-*
 719 }
 720 run_test 21h "drop open request and close reply while close and open are both in flight"
 721
 722 # bug 3462 - multiple MDC requests
 723 test_22() {
 724     f1=$DIR/${tfile}-1
 725     f2=$DIR/${tfile}-2
 726
 727     do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000115"
 728     $MULTIOP $f2 Oc &
 729     close_pid=$!
 730
 731     sleep 1
 732     $MULTIOP $f1 msu || return 1
 733
 734     cancel_lru_locks mdc
 735     do_facet $SINGLEMDS "lctl set_param fail_loc=0"
 736
 737     wait $close_pid || return 2
 738     rm -rf $f2 || return 4
 739 }
 740 run_test 22 "drop close request and do mknod"
 741
 742 test_23() { #b=4561
 743     multiop_bg_pause $DIR/$tfile O_c || return 1
 744     pid=$!
 745     # give a chance for open
 746     sleep 5
 747
 748     # try the close
 749     drop_request "kill -USR1 $pid"
 750
 751     fail $SINGLEMDS
 752     wait $pid || return 1
 753     return 0
 754 }
 755 run_test 23 "client hang when close a file after mds crash"
 756
 757 test_24a() { # bug 11710 details correct fsync() behavior
 758         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 759
 760         mkdir -p $DIR/$tdir
 761         $LFS setstripe -i 0 -c 1 $DIR/$tdir
 762         cancel_lru_locks osc
 763         multiop_bg_pause $DIR/$tdir/$tfile Owy_wyc || return 1
 764         MULTI_PID=$!
 765         ost_evict_client
 766         kill -USR1 $MULTI_PID
 767         wait $MULTI_PID
 768         rc=$?
 769         lctl set_param fail_loc=0x0
 770         client_reconnect
 771         [ $rc -eq 0 ] &&
 772                 error_ignore bz5494 "multiop didn't fail fsync: rc $rc" || true
 773 }
 774 run_test 24a "fsync error (should return error)"
 775
 776 wait_client_evicted () {
 777         local facet=$1
 778         local exports=$2
 779         local varsvc=${facet}_svc
 780
 781         wait_update $(facet_active_host $facet) \
 782                 "lctl get_param -n *.${!varsvc}.num_exports | cut -d' ' -f2" \
 783                 $((exports - 1)) $3
 784 }
 785
 786 test_24b() {
 787         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 788
 789         dmesg -c > /dev/null
 790         mkdir -p $DIR/$tdir
 791         lfs setstripe $DIR/$tdir -s 0 -i 0 -c 1
 792         cancel_lru_locks osc
 793         multiop_bg_pause $DIR/$tdir/$tfile-1 Ow8192_yc ||
 794                 error "mulitop Ow8192_yc failed"
 795
 796         MULTI_PID1=$!
 797         multiop_bg_pause $DIR/$tdir/$tfile-2 Ow8192_c ||
 798                 error "mulitop Ow8192_c failed"
 799
 800         MULTI_PID2=$!
 801         ost_evict_client
 802
 803         kill -USR1 $MULTI_PID1
 804         wait $MULTI_PID1
 805         rc1=$?
 806         kill -USR1 $MULTI_PID2
 807         wait $MULTI_PID2
 808         rc2=$?
 809         lctl set_param fail_loc=0x0
 810         client_reconnect
 811         [ $rc1 -eq 0 -o $rc2 -eq 0 ] &&
 812         error_ignore bz5494 "multiop didn't fail fsync: $rc1 or close: $rc2" ||
 813                 true
 814
 815         dmesg | grep "dirty page discard:" ||
 816                 error "no discarded dirty page found!"
 817 }
 818 run_test 24b "test dirty page discard due to client eviction"
 819
 820 test_26a() {      # was test_26 bug 5921 - evict dead exports by pinger
 821 # this test can only run from a client on a separate node.
 822         remote_ost || { skip "local OST" && return 0; }
 823         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 824         remote_mds || { skip "local MDS" && return 0; }
 825
 826         if [ $(facet_host mgs) = $(facet_host ost1) ]; then
 827                 skip "msg and ost1 are at the same node"
 828                 return 0
 829         fi
 830
 831         check_timeout || return 1
 832
 833         local OST_NEXP=$(do_facet ost1 lctl get_param -n obdfilter.${ost1_svc}.num_exports | cut -d' ' -f2)
 834
 835         echo starting with $OST_NEXP OST exports
 836 # OBD_FAIL_PTLRPC_DROP_RPC 0x505
 837         do_facet client lctl set_param fail_loc=0x505
 838         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.
 839         # But if there's a race to start the evictor from various obds,
 840         # the loser might have to wait for the next ping.
 841
 842         local rc=0
 843         wait_client_evicted ost1 $OST_NEXP $((TIMEOUT * 2 + TIMEOUT * 3 / 4))
 844         rc=$?
 845         do_facet client lctl set_param fail_loc=0x0
 846         [ $rc -eq 0 ] || error "client not evicted from OST"
 847 }
 848 run_test 26a "evict dead exports"
 849
 850 test_26b() {      # bug 10140 - evict dead exports by pinger
 851         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
 852
 853         if [ $(facet_host mgs) = $(facet_host ost1) ]; then
 854                 skip "msg and ost1 are at the same node"
 855                 return 0
 856         fi
 857
 858         check_timeout || return 1
 859         clients_up
 860         zconf_mount `hostname` $MOUNT2 ||
 861                 { error "Failed to mount $MOUNT2"; return 2; }
 862         sleep 1 # wait connections being established
 863
 864         local MDS_NEXP=$(do_facet $SINGLEMDS lctl get_param -n mdt.${mds1_svc}.num_exports | cut -d' ' -f2)
 865         local OST_NEXP=$(do_facet ost1 lctl get_param -n obdfilter.${ost1_svc}.num_exports | cut -d' ' -f2)
 866
 867         echo starting with $OST_NEXP OST and $MDS_NEXP MDS exports
 868
 869         zconf_umount `hostname` $MOUNT2 -f
 870
 871         # PING_INTERVAL max(obd_timeout / 4, 1U)
 872         # PING_EVICT_TIMEOUT (PING_INTERVAL * 6)
 873
 874         # evictor takes PING_EVICT_TIMEOUT + 3 * PING_INTERVAL to evict.
 875         # But if there's a race to start the evictor from various obds,
 876         # the loser might have to wait for the next ping.
 877         # = 9 * PING_INTERVAL + PING_INTERVAL
 878         # = 10 PING_INTERVAL = 10 obd_timeout / 4 = 2.5 obd_timeout
 879         # let's wait $((TIMEOUT * 3)) # bug 19887
 880         local rc=0
 881         wait_client_evicted ost1 $OST_NEXP $((TIMEOUT * 3)) || \
 882                 error "Client was not evicted by ost" rc=1
 883         wait_client_evicted $SINGLEMDS $MDS_NEXP $((TIMEOUT * 3)) || \
 884                 error "Client was not evicted by mds"
 885 }
 886 run_test 26b "evict dead exports"
 887
 888 test_27() {
 889         mkdir -p $DIR/$tdir
 890         writemany -q -a $DIR/$tdir/$tfile 0 5 &
 891         CLIENT_PID=$!
 892         sleep 1
 893         local save_FAILURE_MODE=$FAILURE_MODE
 894         FAILURE_MODE="SOFT"
 895         facet_failover $SINGLEMDS
 896 #define OBD_FAIL_OSC_SHUTDOWN            0x407
 897         do_facet $SINGLEMDS lctl set_param fail_loc=0x80000407
 898         # need to wait for reconnect
 899         echo waiting for fail_loc
 900         wait_update_facet $SINGLEMDS "lctl get_param -n fail_loc" "-2147482617"
 901         facet_failover $SINGLEMDS
 902         #no crashes allowed!
 903         kill -USR1 $CLIENT_PID
 904         wait $CLIENT_PID
 905         true
 906         FAILURE_MODE=$save_FAILURE_MODE
 907 }
 908 run_test 27 "fail LOV while using OSC's"
 909
 910 test_28() {      # bug 6086 - error adding new clients
 911         do_facet client mcreate $DIR/$tfile       || return 1
 912         drop_bl_callback "chmod 0777 $DIR/$tfile" ||echo "evicted as expected"
 913         #define OBD_FAIL_MDS_CLIENT_ADD 0x12f
 914         do_facet $SINGLEMDS "lctl set_param fail_loc=0x8000012f"
 915         # fail once (evicted), reconnect fail (fail_loc), ok
 916         client_up || (sleep 10; client_up) || (sleep 10; client_up) || error "reconnect failed"
 917         rm -f $DIR/$tfile
 918         fail $SINGLEMDS         # verify MDS last_rcvd can be loaded
 919 }
 920 run_test 28 "handle error adding new clients (bug 6086)"
 921
 922 test_29a() { # bug 22273 - error adding new clients
 923         #define OBD_FAIL_TGT_CLIENT_ADD 0x711
 924         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000711"
 925         # fail abort so client will be new again
 926         fail_abort $SINGLEMDS
 927         client_up || error "reconnect failed"
 928         wait_osc_import_state $SINGLEMDS ost FULL
 929         return 0
 930 }
 931 run_test 29a "error adding new clients doesn't cause LBUG (bug 22273)"
 932
 933 test_29b() { # bug 22273 - error adding new clients
 934         #define OBD_FAIL_TGT_CLIENT_ADD 0x711
 935         do_facet ost1 "lctl set_param fail_loc=0x80000711"
 936         # fail abort so client will be new again
 937         fail_abort ost1
 938         client_up || error "reconnect failed"
 939         return 0
 940 }
 941 run_test 29b "error adding new clients doesn't cause LBUG (bug 22273)"
 942
 943 test_50() {
 944         mkdir -p $DIR/$tdir
 945         # put a load of file creates/writes/deletes
 946         writemany -q $DIR/$tdir/$tfile 0 5 &
 947         CLIENT_PID=$!
 948         echo writemany pid $CLIENT_PID
 949         sleep 10
 950         FAILURE_MODE="SOFT"
 951         fail $SINGLEMDS
 952         # wait for client to reconnect to MDS
 953         sleep 60
 954         fail $SINGLEMDS
 955         sleep 60
 956         fail $SINGLEMDS
 957         # client process should see no problems even though MDS went down
 958         sleep $TIMEOUT
 959         kill -USR1 $CLIENT_PID
 960         wait $CLIENT_PID
 961         rc=$?
 962         echo writemany returned $rc
 963         #these may fail because of eviction due to slow AST response.
 964         [ $rc -eq 0 ] ||
 965                 error_ignore bz13652 "writemany returned rc $rc" || true
 966 }
 967 run_test 50 "failover MDS under load"
 968
 969 test_51() {
 970         #define OBD_FAIL_MDS_SYNC_CAPA_SL                    0x1310
 971         do_facet ost1 lctl set_param fail_loc=0x00001310
 972
 973         mkdir -p $DIR/$tdir
 974         # put a load of file creates/writes/deletes
 975         writemany -q $DIR/$tdir/$tfile 0 5 &
 976         CLIENT_PID=$!
 977         sleep 1
 978         FAILURE_MODE="SOFT"
 979         facet_failover $SINGLEMDS
 980         # failover at various points during recovery
 981         SEQ="1 5 10 $(seq $TIMEOUT 5 $(($TIMEOUT+10)))"
 982         echo will failover at $SEQ
 983         for i in $SEQ
 984         do
 985                 #echo failover in $i sec
 986                 log "test_$testnum: failover in $i sec"
 987                 sleep $i
 988                 facet_failover $SINGLEMDS
 989         done
 990         # client process should see no problems even though MDS went down
 991         # and recovery was interrupted
 992         sleep $TIMEOUT
 993         kill -USR1 $CLIENT_PID
 994         wait $CLIENT_PID
 995         rc=$?
 996         echo writemany returned $rc
 997         [ $rc -eq 0 ] ||
 998                 error_ignore bz13652 "writemany returned rc $rc" || true
 999 }
1000 run_test 51 "failover MDS during recovery"
1001
1002 test_52_guts() {
1003         do_facet client "mkdir -p $DIR/$tdir"
1004         do_facet client "writemany -q -a $DIR/$tdir/$tfile 300 5" &
1005         CLIENT_PID=$!
1006         echo writemany pid $CLIENT_PID
1007         sleep 10
1008         FAILURE_MODE="SOFT"
1009         fail ost1
1010         rc=0
1011         wait $CLIENT_PID || rc=$?
1012         # active client process should see an EIO for down OST
1013         [ $rc -eq 5 ] && { echo "writemany correctly failed $rc" && return 0; }
1014         # but timing or failover setup may allow success
1015         [ $rc -eq 0 ] && { echo "writemany succeeded" && return 0; }
1016         echo "writemany returned $rc"
1017         return $rc
1018 }
1019
1020 test_52() {
1021         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1022
1023         mkdir -p $DIR/$tdir
1024         test_52_guts
1025         rc=$?
1026         [ $rc -ne 0 ] && { return $rc; }
1027         # wait for client to reconnect to OST
1028         sleep 30
1029         test_52_guts
1030         rc=$?
1031         [ $rc -ne 0 ] && { return $rc; }
1032         sleep 30
1033         test_52_guts
1034         rc=$?
1035         client_reconnect
1036         #return $rc
1037 }
1038 run_test 52 "failover OST under load"
1039
1040 # test of open reconstruct
1041 test_53() {
1042         touch $DIR/$tfile
1043         drop_ldlm_reply "openfile -f O_RDWR:O_CREAT -m 0755 $DIR/$tfile" ||\
1044                 return 2
1045 }
1046 run_test 53 "touch: drop rep"
1047
1048 test_54() {
1049         zconf_mount `hostname` $MOUNT2
1050         touch $DIR/$tfile
1051         touch $DIR2/$tfile.1
1052         sleep 10
1053         cat $DIR2/$tfile.missing # save transno = 0, rc != 0 into last_rcvd
1054         fail $SINGLEMDS
1055         umount $MOUNT2
1056         ERROR=`dmesg | egrep "(test 54|went back in time)" | tail -n1 | grep "went back in time"`
1057         [ x"$ERROR" == x ] || error "back in time occured"
1058 }
1059 run_test 54 "back in time"
1060
1061 # bug 11330 - liblustre application death during I/O locks up OST
1062 test_55() {
1063         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1064
1065         mkdir -p $DIR/$tdir
1066
1067         # Minimum pass speed is 2MBps
1068         local ddtimeout=64
1069         # LU-2887/LU-3089 - set min pass speed to 500KBps
1070         [ "$(facet_fstype ost1)" = "zfs" ] && ddtimeout=256
1071
1072         # first dd should be finished quickly
1073         $LFS setstripe -c 1 -i 0 $DIR/$tdir/$tfile-1
1074         dd if=/dev/zero of=$DIR/$tdir/$tfile-1 bs=32M count=4 &
1075         DDPID=$!
1076         count=0
1077         echo  "step1: testing ......"
1078         while kill -0 $DDPID 2> /dev/null; do
1079                 let count++
1080                 if [ $count -gt $ddtimeout ]; then
1081                         error "dd should be finished!"
1082                 fi
1083                 sleep 1
1084         done
1085         echo "(dd_pid=$DDPID, time=$count)successful"
1086
1087         $LFS setstripe -c 1 -i 0 $DIR/$tdir/$tfile-2
1088         #define OBD_FAIL_OST_DROP_REQ            0x21d
1089         do_facet ost1 lctl set_param fail_loc=0x0000021d
1090         # second dd will be never finished
1091         dd if=/dev/zero of=$DIR/$tdir/$tfile-2 bs=32M count=4 &
1092         DDPID=$!
1093         count=0
1094         echo  "step2: testing ......"
1095         while [ $count -le $ddtimeout ]; do
1096                 if ! kill -0 $DDPID 2> /dev/null; then
1097                         ls -l $DIR/$tdir
1098                         error "dd shouldn't be finished! (time=$count)"
1099                 fi
1100                 let count++
1101                 sleep 1
1102         done
1103         echo "(dd_pid=$DDPID, time=$count)successful"
1104
1105         #Recover fail_loc and dd will finish soon
1106         do_facet ost1 lctl set_param fail_loc=0
1107         count=0
1108         echo  "step3: testing ......"
1109         while kill -0 $DDPID 2> /dev/null; do
1110                 let count++
1111                 if [ $count -gt $((ddtimeout + 440)) ]; then
1112                         error "dd should be finished!"
1113                 fi
1114                 sleep 1
1115         done
1116         echo "(dd_pid=$DDPID, time=$count)successful"
1117
1118         rm -rf $DIR/$tdir
1119 }
1120 run_test 55 "ost_brw_read/write drops timed-out read/write request"
1121
1122 test_56() { # b=11277
1123 #define OBD_FAIL_MDS_RESEND      0x136
1124         touch $DIR/$tfile
1125         do_facet $SINGLEMDS "lctl set_param fail_loc=0x80000136"
1126         stat $DIR/$tfile || error "stat failed"
1127         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
1128         rm -f $DIR/$tfile
1129 }
1130 run_test 56 "do not fail on getattr resend"
1131
1132 test_57_helper() {
1133         # no oscs means no client or mdt
1134         while lctl get_param osc.*.* > /dev/null 2>&1; do
1135                 : # loop until proc file is removed
1136         done
1137 }
1138
1139 test_57() { # bug 10866
1140         test_57_helper &
1141         pid=$!
1142         sleep 1
1143 #define OBD_FAIL_LPROC_REMOVE            0xB00
1144         lctl set_param fail_loc=0x80000B00
1145         zconf_umount `hostname` $DIR
1146         lctl set_param fail_loc=0x80000B00
1147         fail_abort $SINGLEMDS
1148         kill -9 $pid
1149         lctl set_param fail_loc=0
1150         mount_client $DIR
1151         do_facet client "df $DIR"
1152 }
1153 run_test 57 "read procfs entries causes kernel crash"
1154
1155 test_58() { # bug 11546
1156 #define OBD_FAIL_MDC_ENQUEUE_PAUSE        0x801
1157         touch $DIR/$tfile
1158         ls -la $DIR/$tfile
1159         lctl set_param fail_loc=0x80000801
1160         cp $DIR/$tfile /dev/null &
1161         pid=$!
1162         sleep 1
1163         lctl set_param fail_loc=0
1164         drop_bl_callback rm -f $DIR/$tfile
1165         wait $pid
1166         # the first 'df' could tigger the eviction caused by
1167         # 'drop_bl_callback', and it's normal case.
1168         # but the next 'df' should return successfully.
1169         do_facet client "df $DIR" || do_facet client "df $DIR"
1170 }
1171 run_test 58 "Eviction in the middle of open RPC reply processing"
1172
1173 test_59() { # bug 10589
1174         zconf_mount `hostname` $MOUNT2 || error "Failed to mount $MOUNT2"
1175         echo $DIR2 | grep -q $MOUNT2 || error "DIR2 is not set properly: $DIR2"
1176 #define OBD_FAIL_LDLM_CANCEL_EVICT_RACE  0x311
1177         lctl set_param fail_loc=0x311
1178         writes=$(LANG=C dd if=/dev/zero of=$DIR2/$tfile count=1 2>&1)
1179         [ $? = 0 ] || error "dd write failed"
1180         writes=$(echo $writes | awk  -F '+' '/out/ {print $1}')
1181         lctl set_param fail_loc=0
1182         sync
1183         zconf_umount `hostname` $MOUNT2 -f
1184         reads=$(LANG=C dd if=$DIR/$tfile of=/dev/null 2>&1)
1185         [ $? = 0 ] || error "dd read failed"
1186         reads=$(echo $reads | awk -F '+' '/in/ {print $1}')
1187         [ "$reads" -eq "$writes" ] || error "read" $reads "blocks, must be" $writes
1188 }
1189 run_test 59 "Read cancel race on client eviction"
1190
1191 err17935 () {
1192         # we assume that all md changes are in the MDT0 changelog
1193         if [ $MDSCOUNT -gt 1 ]; then
1194                 error_ignore bz17935 $*
1195         else
1196                 error $*
1197         fi
1198 }
1199
1200 test_60() {
1201         MDT0=$($LCTL get_param -n mdc.*.mds_server_uuid |
1202                 awk '{ gsub(/_UUID/,""); print $1 }' | head -n1)
1203
1204         NUM_FILES=15000
1205         mkdir -p $DIR/$tdir
1206
1207         # Register (and start) changelog
1208         USER=$(do_facet $SINGLEMDS lctl --device $MDT0 changelog_register -n)
1209         echo "Registered as $MDT0 changelog user $USER"
1210
1211         # Generate a large number of changelog entries
1212         createmany -o $DIR/$tdir/$tfile $NUM_FILES
1213         sync
1214         sleep 5
1215
1216         # Unlink files in the background
1217         unlinkmany $DIR/$tdir/$tfile $NUM_FILES &
1218         CLIENT_PID=$!
1219         sleep 1
1220
1221         # Failover the MDS while unlinks are happening
1222         facet_failover $SINGLEMDS
1223
1224         # Wait for unlinkmany to finish
1225         wait $CLIENT_PID
1226
1227         # Check if all the create/unlink events were recorded
1228         # in the changelog
1229         $LFS changelog $MDT0 >> $DIR/$tdir/changelog
1230         local cl_count=$(grep UNLNK $DIR/$tdir/changelog | wc -l)
1231         echo "$cl_count unlinks in $MDT0 changelog"
1232
1233         do_facet $SINGLEMDS lctl --device $MDT0 changelog_deregister $USER
1234         USERS=$(( $(do_facet $SINGLEMDS lctl get_param -n \
1235             mdd.$MDT0.changelog_users | wc -l) - 2 ))
1236         if [ $USERS -eq 0 ]; then
1237             [ $cl_count -eq $NUM_FILES ] || \
1238                 err17935 "Recorded ${cl_count} unlinks out of $NUM_FILES"
1239             # Also make sure we can clear large changelogs
1240             cl_count=$($LFS changelog $FSNAME | wc -l)
1241             [ $cl_count -le 2 ] || \
1242                 error "Changelog not empty: $cl_count entries"
1243         else
1244             # If there are other users, there may be other unlinks in the log
1245             [ $cl_count -ge $NUM_FILES ] || \
1246                 err17935 "Recorded ${cl_count} unlinks out of $NUM_FILES"
1247             echo "$USERS other changelog users; can't verify clear"
1248         fi
1249 }
1250 run_test 60 "Add Changelog entries during MDS failover"
1251
1252 test_61()
1253 {
1254         local mdtosc=$(get_mdtosc_proc_path $SINGLEMDS $FSNAME-OST0000)
1255         mdtosc=${mdtosc/-MDT*/-MDT\*}
1256         local cflags="osc.$mdtosc.connect_flags"
1257         do_facet $SINGLEMDS "lctl get_param -n $cflags" |grep -q skip_orphan
1258         [ $? -ne 0 ] && skip "don't have skip orphan feature" && return
1259
1260         mkdir -p $DIR/$tdir || error "mkdir dir $DIR/$tdir failed"
1261         # Set the default stripe of $DIR/$tdir to put the files to ost1
1262         $LFS setstripe -c 1 -i 0 $DIR/$tdir
1263
1264         replay_barrier $SINGLEMDS
1265         createmany -o $DIR/$tdir/$tfile-%d 10
1266         local oid=`do_facet ost1 "lctl get_param -n obdfilter.${ost1_svc}.last_id"`
1267
1268         fail_abort $SINGLEMDS
1269
1270         touch $DIR/$tdir/$tfile
1271         local id=`$LFS getstripe $DIR/$tdir/$tfile | awk '$1 == 0 { print $2 }'`
1272         [ $id -le $oid ] && error "the orphan objid was reused, failed"
1273
1274         # Cleanup
1275         rm -rf $DIR/$tdir
1276 }
1277 run_test 61 "Verify to not reuse orphan objects - bug 17025"
1278
1279 # test_62 as seen it b2_1 please do not reuse test_62
1280 #test_62()
1281 #{
1282 #       zconf_umount `hostname` $DIR
1283 #       #define OBD_FAIL_PTLRPC_DELAY_IMP_FULL   0x516
1284 #       lctl set_param fail_loc=0x516
1285 #       mount_client $DIR
1286 #}
1287 #run_test 62 "Verify connection flags race - bug LU-1716"
1288
1289 check_cli_ir_state()
1290 {
1291         local NODE=${1:-$HOSTNAME}
1292         local st
1293         st=$(do_node $NODE "lctl get_param mgc.*.ir_state |
1294                             awk '/imperative_recovery:/ { print \\\$2}'")
1295         [ $st != ON -o $st != OFF -o $st != ENABLED -o $st != DISABLED ] ||
1296                 error "Error state $st, must be ENABLED or DISABLED"
1297         echo -n $st
1298 }
1299
1300 check_target_ir_state()
1301 {
1302         local target=${1}
1303         local name=${target}_svc
1304         local recovery_proc=obdfilter.${!name}.recovery_status
1305         local st
1306
1307         st=$(do_facet $target "lctl get_param -n $recovery_proc |
1308                                awk '/IR:/{ print \\\$2}'")
1309         [ $st != ON -o $st != OFF -o $st != ENABLED -o $st != DISABLED ] ||
1310                 error "Error state $st, must be ENABLED or DISABLED"
1311         echo -n $st
1312 }
1313
1314 set_ir_status()
1315 {
1316         do_facet mgs lctl set_param -n mgs.MGS.live.$FSNAME="state=$1"
1317 }
1318
1319 get_ir_status()
1320 {
1321         local state=$(do_facet mgs "lctl get_param -n mgs.MGS.live.$FSNAME |
1322                                     awk '/state:/{ print \\\$2 }'")
1323         echo -n ${state/,/}
1324 }
1325
1326 nidtbl_version_mgs()
1327 {
1328         local ver=$(do_facet mgs "lctl get_param -n mgs.MGS.live.$FSNAME |
1329                                   awk '/nidtbl_version:/{ print \\\$2 }'")
1330         echo -n $ver
1331 }
1332
1333 # nidtbl_version_client <mds1|client> [node]
1334 nidtbl_version_client()
1335 {
1336         local cli=$1
1337         local node=${2:-$HOSTNAME}
1338
1339         if [ X$cli = Xclient ]; then
1340                 cli=$FSNAME-client
1341         else
1342                 local obdtype=${cli/%[0-9]*/}
1343                 [ $obdtype != mds ] && error "wrong parameters $cli"
1344
1345                 node=$(facet_active_host $cli)
1346                 local t=${cli}_svc
1347                 cli=${!t}
1348         fi
1349
1350         local vers=$(do_node $node "lctl get_param -n mgc.*.ir_state" |
1351                      awk "/$cli/{print \$6}" |sort -u)
1352
1353         # in case there are multiple mounts on the client node
1354         local arr=($vers)
1355         [ ${#arr[@]} -ne 1 ] && error "versions on client node mismatch"
1356         echo -n $vers
1357 }
1358
1359 nidtbl_versions_match()
1360 {
1361         [ $(nidtbl_version_mgs) -eq $(nidtbl_version_client ${1:-client}) ]
1362 }
1363
1364 target_instance_match()
1365 {
1366         local srv=$1
1367         local obdtype
1368         local cliname
1369
1370         obdtype=${srv/%[0-9]*/}
1371         case $obdtype in
1372         mds)
1373                 obdname="mdt"
1374                 cliname="mdc"
1375                 ;;
1376         ost)
1377                 obdname="obdfilter"
1378                 cliname="osc"
1379                 ;;
1380         *)
1381                 error "invalid target type" $srv
1382                 return 1
1383                 ;;
1384         esac
1385
1386         local target=${srv}_svc
1387         local si=$(do_facet $srv lctl get_param -n $obdname.${!target}.instance)
1388         local ci=$(lctl get_param -n $cliname.${!target}-${cliname}-*.import |
1389                 awk '/instance/{ print $2 }' | head -n1)
1390
1391         return $([ $si -eq $ci ])
1392 }
1393
1394 test_100()
1395 {
1396         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1397                 { skip "MGS without IR support"; return 0; }
1398
1399         # MDT was just restarted in the previous test, make sure everything
1400         # is all set.
1401         local cnt=30
1402         while [ $cnt -gt 0 ]; do
1403                 nidtbl_versions_match && break
1404                 sleep 1
1405                 cnt=$((cnt - 1))
1406         done
1407
1408         # disable IR
1409         set_ir_status disabled
1410
1411         local prev_ver=$(nidtbl_version_client client)
1412
1413         local saved_FAILURE_MODE=$FAILURE_MODE
1414         [ $(facet_host mgs) = $(facet_host ost1) ] && FAILURE_MODE="SOFT"
1415         fail ost1
1416
1417         # valid check
1418         [ $(nidtbl_version_client client) -eq $prev_ver ] ||
1419                 error "version must not change due to IR disabled"
1420         target_instance_match ost1 || error "instance mismatch"
1421
1422         # restore env
1423         set_ir_status full
1424         FAILURE_MODE=$saved_FAILURE_MODE
1425 }
1426 run_test 100 "IR: Make sure normal recovery still works w/o IR"
1427
1428 test_101()
1429 {
1430         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1431                 { skip "MGS without IR support"; return 0; }
1432
1433         set_ir_status full
1434
1435         local OST1_IMP=$(get_osc_import_name client ost1)
1436
1437         # disable pinger recovery
1438         lctl set_param -n osc.$OST1_IMP.pinger_recov=0
1439
1440         fail ost1
1441
1442         target_instance_match ost1 || error "instance mismatch"
1443         nidtbl_versions_match || error "version must match"
1444
1445         lctl set_param -n osc.$OST1_IMP.pinger_recov=1
1446 }
1447 run_test 101 "IR: Make sure IR works w/o normal recovery"
1448
1449 test_102()
1450 {
1451         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1452                 { skip "MGS without IR support"; return 0; }
1453
1454         local clients=${CLIENTS:-$HOSTNAME}
1455         local old_version
1456         local new_version
1457         local mgsdev=mgs
1458
1459         set_ir_status full
1460
1461         # let's have a new nidtbl version
1462         fail ost1
1463
1464         # sleep for a while so that clients can see the failure of ost
1465         # it must be MGC_TIMEOUT_MIN_SECONDS + MGC_TIMEOUT_RAND_CENTISEC.
1466         # int mgc_request.c:
1467         # define MGC_TIMEOUT_MIN_SECONDS   5
1468         # define MGC_TIMEOUT_RAND_CENTISEC 0x1ff /* ~500 *
1469         local count=30  # 20 seconds at most
1470         while [ $count -gt 0 ]; do
1471                 nidtbl_versions_match && break
1472                 sleep 1
1473                 count=$((count-1))
1474         done
1475
1476         nidtbl_versions_match || error "nidtbl mismatch"
1477
1478         # get the version #
1479         old_version=$(nidtbl_version_client client)
1480
1481         zconf_umount_clients $clients $MOUNT || error "Cannot umount client"
1482
1483         # restart mgs
1484         combined_mgs_mds && mgsdev=mds1
1485         remount_facet $mgsdev
1486         fail ost1
1487
1488         zconf_mount_clients $clients $MOUNT || error "Cannot mount client"
1489
1490         # check new version
1491         new_version=$(nidtbl_version_client client)
1492         [ $new_version -lt $old_version ] &&
1493                 error "nidtbl version wrong after mgs restarts"
1494         return 0
1495 }
1496 run_test 102 "IR: New client gets updated nidtbl after MGS restart"
1497
1498 test_103()
1499 {
1500         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1501                 { skip "MGS without IR support"; return 0; }
1502
1503         combined_mgs_mds && skip "mgs and mds on the same target" && return 0
1504
1505         # workaround solution to generate config log on the mds
1506         remount_facet mds1
1507
1508         stop mgs
1509         stop mds1
1510
1511         # We need this test because mds is like a client in IR context.
1512         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS ||
1513                 error "MDS should start w/o mgs"
1514
1515         # start mgs and remount mds w/ ir
1516         start mgs $(mgsdevname) $MGS_MOUNT_OPTS
1517         clients_up
1518
1519         # remount client so that fsdb will be created on the MGS
1520         umount_client $MOUNT || error "umount failed"
1521         mount_client $MOUNT || error "mount failed"
1522
1523         # sleep 30 seconds so the MDS has a chance to detect MGS restarting
1524         local count=30
1525         while [ $count -gt 0 ]; do
1526                 [ $(nidtbl_version_client mds1) -ne 0 ] && break
1527                 sleep 1
1528                 count=$((count-1))
1529         done
1530
1531         # after a while, mds should be able to reconnect to mgs and fetch
1532         # up-to-date nidtbl version
1533         nidtbl_versions_match mds1 || error "mds nidtbl mismatch"
1534
1535         # reset everything
1536         set_ir_status full
1537 }
1538 run_test 103 "IR: MDS can start w/o MGS and get updated nidtbl later"
1539
1540 test_104()
1541 {
1542         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1543                 { skip "MGS without IR support"; return 0; }
1544
1545         set_ir_status full
1546
1547         stop ost1
1548         start ost1 $(ostdevname 1) "$OST_MOUNT_OPTS -onoir" ||
1549                 error "OST1 cannot start"
1550         clients_up
1551
1552         local ir_state=$(check_target_ir_state ost1)
1553         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1554                 error "ir status on ost1 should be DISABLED"
1555 }
1556 run_test 104 "IR: ost can disable IR voluntarily"
1557
1558 test_105()
1559 {
1560         [ -z "$RCLIENTS" ] && skip "Needs multiple clients" && return 0
1561         do_facet mgs $LCTL list_param mgs.*.ir_timeout ||
1562                 { skip "MGS without IR support"; return 0; }
1563
1564         set_ir_status full
1565
1566         # get one of the clients from client list
1567         local rcli=$(echo $RCLIENTS |cut -d' ' -f 1)
1568
1569         local old_MOUNTOPT=$MOUNTOPT
1570         MOUNTOPT=${MOUNTOPT},noir
1571         zconf_umount $rcli $MOUNT || error "umount failed"
1572         zconf_mount $rcli $MOUNT || error "mount failed"
1573
1574         # make sure lustre mount at $rcli disabling IR
1575         local ir_state=$(check_cli_ir_state $rcli)
1576         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1577                 error "IR state must be DISABLED at $rcli"
1578
1579         # Since the client just mounted, its last_rcvd entry is not on disk.
1580         # Send an RPC so exp_need_sync forces last_rcvd to commit this export
1581         # so the client can reconnect during OST recovery (LU-924, LU-1582)
1582         $SETSTRIPE -i 0 $DIR/$tfile
1583         dd if=/dev/zero of=$DIR/$tfile bs=1M count=1 conv=sync
1584
1585         # make sure MGS's state is Partial
1586         [ $(get_ir_status) = "partial" ] || error "MGS IR state must be partial"
1587
1588         fail ost1
1589         # make sure IR on ost1 is DISABLED
1590         local ir_state=$(check_target_ir_state ost1)
1591         [ $ir_state = "DISABLED" -o $ir_state = "OFF" ] ||
1592                 error "IR status on ost1 should be DISABLED"
1593
1594         # restore it
1595         MOUNTOPT=$old_MOUNTOPT
1596         zconf_umount $rcli $MOUNT || error "umount failed"
1597         zconf_mount $rcli $MOUNT || error "mount failed"
1598
1599         # make sure MGS's state is full
1600         [ $(get_ir_status) = "full" ] || error "MGS IR status must be full"
1601
1602         fail ost1
1603         # make sure IR on ost1 is ENABLED
1604         local ir_state=$(check_target_ir_state ost1)
1605         [ $ir_state = "ENABLED" -o $ir_state = "ON" ] ||
1606                 error "IR status on ost1 should be ENABLED"
1607
1608         return 0
1609 }
1610 run_test 105 "IR: NON IR clients support"
1611
1612 cleanup_106() {
1613         trap 0
1614         umount_client $DIR2
1615         debugrestore
1616 }
1617
1618 test_106() { # LU-1789
1619         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.50) ]] ||
1620                 { skip "Need MDS version at least 2.3.50"; return 0; }
1621
1622 #define OBD_FAIL_MDC_LIGHTWEIGHT         0x805
1623         $LCTL set_param fail_loc=0x805
1624
1625         debugsave
1626         trap cleanup_106 EXIT
1627
1628         # enable lightweight flag on mdc connection
1629         mount_client $DIR2
1630
1631         local MDS_NEXP=$(do_facet $SINGLEMDS \
1632                          lctl get_param -n mdt.${mds1_svc}.num_exports |
1633                          cut -d' ' -f2)
1634         $LCTL set_param fail_loc=0
1635
1636         touch $DIR2/$tfile || error "failed to create empty file"
1637         replay_barrier $SINGLEMDS
1638
1639         $LCTL set_param debug=console
1640         $LCTL clear
1641         facet_failover $SINGLEMDS
1642
1643         # lightweight connection must be evicted
1644         touch -c $DIR2/$tfile || true
1645         $LCTL dk $TMP/lustre-log-$TESTNAME.log
1646         evicted=`awk '/This client was evicted by .*MDT0000/ {
1647                                       print;
1648                       }' $TMP/lustre-log-$TESTNAME.log`
1649         [ -z "$evicted" ] && error "lightweight client not evicted by mds"
1650
1651         # and all operations performed by lightweight client should be
1652         # synchronous, so the file created before mds restart should be there
1653         $CHECKSTAT -t file $DIR/$tfile || error "file not present"
1654         rm -f $DIR/$tfile
1655
1656         cleanup_106
1657 }
1658 run_test 106 "lightweight connection support"
1659
1660 test_107 () {
1661         local CLIENT_PID
1662         local close_pid
1663
1664         mkdir -p $DIR/$tdir
1665         # OBD_FAIL_MDS_REINT_NET_REP   0x119
1666         do_facet $SINGLEMDS lctl set_param fail_loc=0x119
1667         multiop $DIR/$tdir D_c &
1668         close_pid=$!
1669         mkdir $DIR/$tdir/dir_106 &
1670         CLIENT_PID=$!
1671         do_facet $SINGLEMDS lctl set_param fail_loc=0
1672         fail $SINGLEMDS
1673
1674         wait $CLIENT_PID || rc=$?
1675         checkstat -t dir $DIR/$tdir/dir_106 || return 1
1676
1677         kill -USR1 $close_pid
1678         wait $close_pid || return 2
1679
1680         return $rc
1681 }
1682 run_test 107 "drop reint reply, then restart MDT"
1683
1684 test_110a () {
1685         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1686         local remote_dir=$DIR/$tdir/remote_dir
1687         local MDTIDX=1
1688         local num
1689
1690         #prepare for 110 test, which need set striped dir on remote MDT.
1691         for num in $(seq $MDSCOUNT); do
1692                 do_facet mds$num \
1693                         lctl set_param -n mdt.${FSNAME}*.enable_remote_dir=1 \
1694                                 2>/dev/null
1695         done
1696
1697         mkdir -p $DIR/$tdir
1698         drop_request "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1699                                         error "lfs mkdir failed"
1700         local diridx=$($GETSTRIPE -M $remote_dir)
1701         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1702
1703         rm -rf $DIR/$tdir || error "rmdir failed"
1704 }
1705 run_test 110a "create remote directory: drop client req"
1706
1707 test_110b () {
1708         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1709         local remote_dir=$DIR/$tdir/remote_dir
1710         local MDTIDX=1
1711
1712         mkdir -p $DIR/$tdir
1713         drop_reint_reply "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1714                                         error "lfs mkdir failed"
1715
1716         diridx=$($GETSTRIPE -M $remote_dir)
1717         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1718
1719         rm -rf $DIR/$tdir || error "rmdir failed"
1720 }
1721 run_test 110b "create remote directory: drop Master rep"
1722
1723 test_110c () {
1724         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1725         local remote_dir=$DIR/$tdir/remote_dir
1726         local MDTIDX=1
1727
1728         mkdir -p $DIR/$tdir
1729         drop_update_reply $MDTIDX "$LFS mkdir -i $MDTIDX -c2 $remote_dir" ||
1730                                                 error "lfs mkdir failed"
1731
1732         diridx=$($GETSTRIPE -M $remote_dir)
1733         [ $diridx -eq $MDTIDX ] || error "$diridx != $MDTIDX"
1734
1735         rm -rf $DIR/$tdir || error "rmdir failed"
1736 }
1737 run_test 110c "create remote directory: drop update rep on slave MDT"
1738
1739 test_110d () {
1740         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1741         local remote_dir=$DIR/$tdir/remote_dir
1742         local MDTIDX=1
1743
1744         mkdir -p $DIR/$tdir
1745         $LFS mkdir -i $MDTIDX -c2 $remote_dir || error "lfs mkdir failed"
1746
1747         drop_request "rm -rf $remote_dir" || error "rm remote dir failed"
1748
1749         rm -rf $DIR/$tdir || error "rmdir failed"
1750
1751         return 0
1752 }
1753 run_test 110d "remove remote directory: drop client req"
1754
1755 test_110e () {
1756         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1757         local remote_dir=$DIR/$tdir/remote_dir
1758         local MDTIDX=1
1759
1760         mkdir -p $DIR/$tdir
1761         $LFS mkdir -i $MDTIDX -c2 $remote_dir  || error "lfs mkdir failed"
1762         drop_reint_reply "rm -rf $remote_dir" || error "rm remote dir failed"
1763
1764         rm -rf $DIR/$tdir || error "rmdir failed"
1765
1766         return 0
1767 }
1768 run_test 110e "remove remote directory: drop master rep"
1769
1770 test_110f () {
1771         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1772         local remote_dir=$DIR/$tdir/remote_dir
1773         local MDTIDX=1
1774
1775         mkdir -p $DIR/$tdir
1776         $LFS mkdir -i $MDTIDX -c2 $remote_dir || error "lfs mkdir failed"
1777         drop_update_reply $MDTIDX "rm -rf $remote_dir" ||
1778                                         error "rm remote dir failed"
1779
1780         rm -rf $DIR/$tdir || error "rmdir failed"
1781 }
1782 run_test 110f "remove remote directory: drop slave rep"
1783
1784 test_110g () {
1785         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs" && return 0
1786         local remote_dir=$DIR/$tdir/remote_dir
1787         local MDTIDX=1
1788
1789         mkdir -p $remote_dir
1790
1791         createmany -o $remote_dir/f 100
1792
1793         #define OBD_FAIL_MIGRATE_NET_REP        0x1702
1794         do_facet mds$MDTIDX lctl set_param fail_loc=0x1702
1795         $LFS mv -M $MDTIDX $remote_dir || error "migrate failed"
1796         do_facet mds$MDTIDX lctl set_param fail_loc=0x0
1797
1798         for file in $(find $remote_dir); do
1799                 mdt_index=$($LFS getstripe -M $file)
1800                 [ $mdt_index == $MDTIDX ] ||
1801                         error "$file is not on MDT${MDTIDX}"
1802         done
1803
1804         rm -rf $DIR/$tdir || error "rmdir failed"
1805 }
1806 run_test 110g "drop reply during migration"
1807
1808 # LU-2844 mdt prepare fail should not cause umount oops
1809 test_111 ()
1810 {
1811         [[ $(lustre_version_code $SINGLEMDS) -ge $(version_code 2.3.62) ]] ||
1812                 { skip "Need MDS version at least 2.3.62"; return 0; }
1813
1814         local mdsdev=$(mdsdevname ${SINGLEMDS//mds/})
1815 #define OBD_FAIL_MDS_CHANGELOG_INIT 0x151
1816         do_facet $SINGLEMDS lctl set_param fail_loc=0x151
1817         stop $SINGLEMDS || error "stop MDS failed"
1818         start $SINGLEMDS $mdsdev && error "start MDS should fail"
1819         do_facet $SINGLEMDS lctl set_param fail_loc=0
1820         start $SINGLEMDS $mdsdev || error "start MDS failed"
1821 }
1822 run_test 111 "mdd setup fail should not cause umount oops"
1823
1824 # LU-793
1825 test_112a() {
1826         remote_ost_nodsh && skip "remote OST with nodsh" && return 0
1827
1828         do_facet_random_file client $TMP/$tfile 100K ||
1829                 error_noexit "Create random file $TMP/$tfile"
1830
1831         pause_bulk "cp $TMP/$tfile $DIR/$tfile" $TIMEOUT ||
1832                 error_noexit "Can't pause_bulk copy"
1833
1834         df $DIR
1835         # expect cmp to succeed, client resent bulk
1836         cmp $TMP/$tfile $DIR/$tfile ||
1837                 error_noexit "Wrong data has been written"
1838         rm $DIR/$tfile ||
1839                 error_noexit "Can't remove file"
1840         rm $TMP/$tfile
1841 }
1842 run_test 112a "bulk resend while orignal request is in progress"
1843
1844 # parameters: fail_loc CMD RC
1845 test_120_reply() {
1846         local PID
1847         local PID2
1848         local rc=5
1849         local fail
1850
1851         #define OBD_FAIL_LDLM_CP_CB_WAIT2       0x320
1852         #define OBD_FAIL_LDLM_CP_CB_WAIT3       0x321
1853         #define OBD_FAIL_LDLM_CP_CB_WAIT4       0x322
1854         #define OBD_FAIL_LDLM_CP_CB_WAIT5       0x323
1855
1856         echo
1857         echo -n "** FLOCK REPLY vs. EVICTION race, lock $2"
1858         [ "$1" = "CLEANUP" ] &&
1859                 fail=0x80000320 && echo ", $1 cp first"
1860         [ "$1" = "REPLY" ] &&
1861                 fail=0x80000321 && echo ", $1 cp first"
1862         [ "$1" = "DEADLOCK CLEANUP" ] &&
1863                 fail=0x80000322 && echo " DEADLOCK, CLEANUP cp first"
1864         [ "$1" = "DEADLOCK REPLY" ] &&
1865                 fail=0x80000323 && echo " DEADLOCK, REPLY cp first"
1866
1867         if [ x"$2" = x"get" ]; then
1868                 #for TEST lock, take a conflict in advance
1869                 # sleep longer than evictor to not confuse fail_loc: 2+2+4
1870                 echo "** Taking conflict **"
1871                 flocks_test 5 set read sleep 10 $DIR/$tfile &
1872                 PID2=$!
1873
1874                 sleep 2
1875         fi
1876
1877         $LCTL set_param fail_loc=$fail
1878
1879         flocks_test 5 $2 write $DIR/$tfile &
1880         PID=$!
1881
1882         sleep 2
1883         echo "** Evicting and re-connecting client **"
1884         mds_evict_client
1885
1886         client_reconnect
1887
1888         if [ x"$2" = x"get" ]; then
1889                 wait $PID2
1890         fi
1891
1892         wait $PID
1893         rc=$?
1894
1895         # check if the return value is allowed
1896         [ $rc -eq $3 ] && rc=0
1897
1898         $LCTL set_param fail_loc=0
1899         return $rc
1900 }
1901
1902 # a lock is taken, unlock vs. cleanup_resource() race for destroying
1903 # the ORIGINAL lock.
1904 test_120_destroy()
1905 {
1906         local PID
1907
1908         flocks_test 5 set write sleep 4 $DIR/$tfile &
1909         PID=$!
1910         sleep 2
1911
1912         # let unlock to sleep in CP CB
1913         $LCTL set_param fail_loc=$1
1914         sleep 4
1915
1916         # let cleanup to cleep in CP CB
1917         mds_evict_client
1918
1919         client_reconnect
1920
1921         wait $PID
1922         rc=$?
1923
1924         $LCTL set_param fail_loc=0
1925         return $rc
1926 }
1927
1928 test_120() {
1929         flock_is_enabled || { skip "mount w/o flock enabled" && return; }
1930         touch $DIR/$tfile
1931
1932         test_120_reply "CLEANUP" set 5 || error "SET race failed"
1933         test_120_reply "CLEANUP" get 5 || error "GET race failed"
1934         test_120_reply "CLEANUP" unlock 5 || error "UNLOCK race failed"
1935
1936         test_120_reply "REPLY" set 5 || error "SET race failed"
1937         test_120_reply "REPLY" get 5 || error "GET race failed"
1938         test_120_reply "REPLY" unlock 5 || error "UNLOCK race failed"
1939
1940         # DEADLOCK tests
1941         test_120_reply "DEADLOCK CLEANUP" set 5 || error "DEADLOCK race failed"
1942         test_120_reply "DEADLOCK REPLY" set 35 || error "DEADLOCK race failed"
1943
1944         test_120_destroy 0x320 || error "unlock-cleanup race failed"
1945 }
1946 run_test 120 "flock race: completion vs. evict"
1947
1948 test_113() {
1949         local BEFORE=$(date +%s)
1950         local EVICT
1951
1952         # modify dir so that next revalidate would not obtain UPDATE lock
1953         touch $DIR
1954
1955         # drop 1 reply with UPDATE lock,
1956         # resend should not create 2nd lock on server
1957         mcreate $DIR/$tfile || error "mcreate failed: $?"
1958         drop_ldlm_reply_once "stat $DIR/$tfile" || error "stat failed: $?"
1959
1960         # 2 BL AST will be sent to client, both must find the same lock,
1961         # race them to not get EINVAL for 2nd BL AST
1962         #define OBD_FAIL_LDLM_PAUSE_CANCEL2      0x31f
1963         $LCTL set_param fail_loc=0x8000031f
1964
1965         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=0 > /dev/null
1966         chmod 0777 $DIR/$tfile || error "chmod failed: $?"
1967         $LCTL set_param ldlm.namespaces.*.early_lock_cancel=1 > /dev/null
1968
1969         # let the client reconnect
1970         client_reconnect
1971         EVICT=$($LCTL get_param mdc.$FSNAME-MDT*.state |
1972            awk -F"[ [,]" '/EVICTED]$/ { if (mx<$4) {mx=$4;} } END { print mx }')
1973
1974         [ -z "$EVICT" ] || [[ $EVICT -le $BEFORE ]] || error "eviction happened"
1975 }
1976 run_test 113 "ldlm enqueue dropped reply should not cause deadlocks"
1977
1978 complete $SECONDS
1979 check_and_cleanup_lustre
1980 exit_status