lustre/tests/conf-sanity.sh

   1 #!/bin/bash
   2
   3 set -e
   4
   5 ONLY=${ONLY:-"$*"}
   6
   7 SRCDIR=$(dirname $0)
   8 PTLDEBUG=${PTLDEBUG:--1}
   9 LUSTRE=${LUSTRE:-$(dirname $0)/..}
  10 . $LUSTRE/tests/test-framework.sh
  11 init_test_env "$@"
  12 init_logging
  13
  14 #                                  tool to create lustre filesystem images
  15 ALWAYS_EXCEPT="$CONF_SANITY_EXCEPT 32newtarball"
  16
  17 # bug number for skipped test: LU-11915
  18 ALWAYS_EXCEPT="$ALWAYS_EXCEPT 110"
  19 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  20
  21 if $SHARED_KEY; then
  22         # bug number for skipped tests: LU-9795 (all below)
  23         ALWAYS_EXCEPT="$ALWAYS_EXCEPT   84      86      103"
  24 fi
  25
  26 if ! combined_mgs_mds; then
  27         # bug number for skipped test: LU-11991
  28         ALWAYS_EXCEPT="$ALWAYS_EXCEPT  32a 32b 32c 32d 32e"
  29         # bug number for skipped test: LU-9897  LU-12032
  30         ALWAYS_EXCEPT="$ALWAYS_EXCEPT  84       123F"
  31 fi
  32
  33 #                                     8  22  40 165  (min)
  34 [ "$SLOW" = "no" ] && EXCEPT_SLOW="45 69 106 111 114"
  35
  36 build_test_filter
  37
  38 # use small MDS + OST size to speed formatting time
  39 # do not use too small MDSSIZE/OSTSIZE, which affect the default journal size
  40 # STORED_MDSSIZE is used in test_18
  41 STORED_MDSSIZE=$MDSSIZE
  42 STORED_OSTSIZE=$OSTSIZE
  43 MDSSIZE=200000
  44 [ "$mds1_FSTYPE" = zfs ] && MDSSIZE=400000
  45 OSTSIZE=200000
  46 [ "$ost1_FSTYPE" = zfs ] && OSTSIZE=400000
  47
  48 fs2mds_HOST=$mds_HOST
  49 fs2ost_HOST=$ost_HOST
  50 fs3ost_HOST=$ost_HOST
  51
  52 MDSDEV1_2=$fs2mds_DEV
  53 OSTDEV1_2=$fs2ost_DEV
  54 OSTDEV2_2=$fs3ost_DEV
  55
  56 # pass "-E lazy_itable_init" to mke2fs to speed up the formatting time
  57 if [[ "$LDISKFS_MKFS_OPTS" != *lazy_itable_init* ]]; then
  58         LDISKFS_MKFS_OPTS=$(csa_add "$LDISKFS_MKFS_OPTS" -E lazy_itable_init)
  59 fi
  60
  61 #
  62 require_dsh_mds || exit 0
  63 require_dsh_ost || exit 0
  64
  65 assert_DIR
  66
  67 gen_config() {
  68         # The MGS must be started before the OSTs for a new fs, so start
  69         # and stop to generate the startup logs.
  70         start_mds
  71         start_ost
  72         wait_osc_import_state mds ost FULL
  73         stop_ost
  74         stop_mds
  75 }
  76
  77 reformat_and_config() {
  78         reformat
  79         if ! combined_mgs_mds ; then
  80                 start_mgs
  81         fi
  82         gen_config
  83 }
  84
  85 writeconf_or_reformat() {
  86         # There are at most 2 OSTs for write_conf test
  87         # who knows if/where $TUNEFS is installed?
  88         # Better reformat if it fails...
  89         writeconf_all $MDSCOUNT 2 ||
  90                 { echo "tunefs failed, reformatting instead" &&
  91                   reformat_and_config && return 0; }
  92         return 0
  93 }
  94
  95 reformat() {
  96         formatall
  97 }
  98
  99 start_mgs () {
 100         echo "start mgs service on $(facet_active_host mgs)"
 101         start mgs $(mgsdevname) $MGS_MOUNT_OPTS "$@"
 102 }
 103
 104 start_mdt() {
 105         local num=$1
 106         local facet=mds$num
 107         local dev=$(mdsdevname $num)
 108         shift 1
 109
 110         echo "start mds service on `facet_active_host $facet`"
 111         start $facet ${dev} $MDS_MOUNT_OPTS "$@" || return 94
 112 }
 113
 114 stop_mdt_no_force() {
 115         local num=$1
 116         local facet=mds$num
 117         local dev=$(mdsdevname $num)
 118         shift 1
 119
 120         echo "stop mds service on `facet_active_host $facet`"
 121         stop $facet || return 97
 122 }
 123
 124 stop_mdt() {
 125         local num=$1
 126         local facet=mds$num
 127         local dev=$(mdsdevname $num)
 128         shift 1
 129
 130         echo "stop mds service on `facet_active_host $facet`"
 131         # These tests all use non-failover stop
 132         stop $facet -f || return 97
 133 }
 134
 135 start_mds() {
 136         local mdscount=$MDSCOUNT
 137         local num
 138
 139         [[ "$1" == "--mdscount" ]] && mdscount=$2 && shift 2
 140
 141         for ((num=1; num <= $mdscount; num++ )); do
 142                 start_mdt $num "$@" || return 94
 143         done
 144         for ((num=1; num <= $mdscount; num++ )); do
 145                 wait_clients_import_state ${CLIENTS:-$HOSTNAME} mds${num} FULL
 146         done
 147 }
 148
 149 start_mgsmds() {
 150         if ! combined_mgs_mds ; then
 151                 start_mgs
 152         fi
 153         start_mds "$@"
 154 }
 155
 156 stop_mds() {
 157         local num
 158         for num in $(seq $MDSCOUNT); do
 159                 stop_mdt $num || return 97
 160         done
 161 }
 162
 163 stop_mgs() {
 164         echo "stop mgs service on `facet_active_host mgs`"
 165         # These tests all use non-failover stop
 166         stop mgs -f  || return 97
 167 }
 168
 169 start_ost() {
 170         echo "start ost1 service on `facet_active_host ost1`"
 171         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS "$@" || return 95
 172         wait_clients_import_ready ${CLIENTS:-$HOSTNAME} ost1
 173 }
 174
 175 stop_ost() {
 176         echo "stop ost1 service on `facet_active_host ost1`"
 177         # These tests all use non-failover stop
 178         stop ost1 -f || return 98
 179 }
 180
 181 start_ost2() {
 182         echo "start ost2 service on `facet_active_host ost2`"
 183         start ost2 $(ostdevname 2) $OST_MOUNT_OPTS "$@" || return 92
 184         wait_clients_import_ready ${CLIENTS:-$HOSTNAME} ost2
 185 }
 186
 187 stop_ost2() {
 188         echo "stop ost2 service on `facet_active_host ost2`"
 189         # These tests all use non-failover stop
 190         stop ost2 -f || return 93
 191 }
 192
 193 mount_client() {
 194         local mountpath=$1
 195         local mountopt="$2"
 196
 197         echo "mount $FSNAME ${mountopt:+with opts $mountopt} on $mountpath....."
 198         zconf_mount $HOSTNAME $mountpath $mountopt || return 96
 199 }
 200
 201 umount_client() {
 202         local mountpath=$1
 203         shift
 204         echo "umount lustre on $mountpath....."
 205         zconf_umount $HOSTNAME $mountpath "$@" || return 97
 206 }
 207
 208 manual_umount_client(){
 209         local rc
 210         local FORCE=$1
 211         echo "manual umount lustre on ${MOUNT}...."
 212         do_facet client "umount ${FORCE} $MOUNT"
 213         rc=$?
 214         return $rc
 215 }
 216
 217 setup() {
 218         start_mds || error "MDT start failed"
 219         start_ost || error "Unable to start OST1"
 220         mount_client $MOUNT || error "client start failed"
 221         client_up || error "client_up failed"
 222 }
 223
 224 setup_noconfig() {
 225         start_mgsmds
 226         start_ost
 227         mount_client $MOUNT
 228 }
 229
 230 unload_modules_conf () {
 231         if combined_mgs_mds || ! local_mode; then
 232                 unload_modules || return 1
 233         fi
 234 }
 235
 236 cleanup_nocli() {
 237         stop_ost || return 202
 238         stop_mds || return 201
 239         unload_modules_conf || return 203
 240 }
 241
 242 cleanup() {
 243         local force=""
 244         [ "x$1" != "x" ] && force='-f'
 245         umount_client $MOUNT $force|| return 200
 246         cleanup_nocli || return $?
 247 }
 248
 249 cleanup_fs2() {
 250         trap 0
 251         echo "umount $MOUNT2 ..."
 252         umount $MOUNT2 || true
 253         echo "stopping fs2mds ..."
 254         stop fs2mds -f || true
 255         echo "stopping fs2ost ..."
 256         stop fs2ost -f || true
 257 }
 258
 259 check_mount() {
 260         do_facet client "cp /etc/passwd $DIR/a" || return 71
 261         do_facet client "rm $DIR/a" || return 72
 262         # make sure lustre is actually mounted (touch will block,
 263         # but grep won't, so do it after)
 264         do_facet client "grep $MOUNT' ' /proc/mounts > /dev/null" || return 73
 265         echo "setup single mount lustre success"
 266 }
 267
 268 check_mount2() {
 269         do_facet client "touch $DIR/a" || return 71
 270         do_facet client "rm $DIR/a" || return 72
 271         do_facet client "touch $DIR2/a" || return 73
 272         do_facet client "rm $DIR2/a" || return 74
 273         echo "setup double mount lustre success"
 274 }
 275
 276 generate_name() {
 277         cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w $1 | head -n 1
 278 }
 279
 280 if [ "$ONLY" == "setup" ]; then
 281         setup
 282         exit
 283 fi
 284
 285 if [ "$ONLY" == "cleanup" ]; then
 286         cleanup
 287         exit
 288 fi
 289
 290 init_gss
 291
 292 #create single point mountpoint
 293
 294 reformat_and_config
 295
 296 test_0() {
 297         setup
 298         check_mount || error "check_mount failed"
 299         cleanup || error "cleanup failed with $?"
 300 }
 301 run_test 0 "single mount setup"
 302
 303 test_1() {
 304         start_mds || error "MDS start failed"
 305         start_ost || error "unable to start OST"
 306         echo "start ost second time..."
 307         start_ost && error "2nd OST start should fail"
 308         mount_client $MOUNT || error "client start failed"
 309         check_mount || error "check_mount failed"
 310         cleanup || error "cleanup failed with $?"
 311 }
 312 run_test 1 "start up ost twice (should return errors)"
 313
 314 test_2() {
 315         start_mds || error "MDT start failed"
 316         echo "start mds second time.."
 317         start_mds && error "2nd MDT start should fail"
 318         start_ost || error "OST start failed"
 319         mount_client $MOUNT || error "mount_client failed to start client"
 320         check_mount || error "check_mount failed"
 321         cleanup || error "cleanup failed with $?"
 322 }
 323 run_test 2 "start up mds twice (should return err)"
 324
 325 test_3() {
 326         setup
 327         #mount.lustre returns an error if already in mtab
 328         mount_client $MOUNT && error "2nd client mount should fail"
 329         check_mount || error "check_mount failed"
 330         cleanup || error "cleanup failed with $?"
 331 }
 332 run_test 3 "mount client twice (should return err)"
 333
 334 test_4() {
 335         setup
 336         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 337         stop_ost || error "Unable to stop OST1"
 338         umount_client $MOUNT -f || error "unmount $MOUNT failed"
 339         cleanup_nocli
 340         eno=$?
 341         # ok for ost to fail shutdown
 342         if [ 202 -ne $eno ] && [ 0 -ne $eno ]; then
 343                 error "cleanup failed with $?"
 344         fi
 345 }
 346 run_test 4 "force cleanup ost, then cleanup"
 347
 348 test_5a() {     # was test_5
 349         setup
 350         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 351         fuser -m -v $MOUNT && echo "$MOUNT is in use by user space process."
 352
 353         stop_mds || error "Unable to stop MDS"
 354
 355         # cleanup may return an error from the failed
 356         # disconnects; for now I'll consider this successful
 357         # if all the modules have unloaded.
 358         $UMOUNT -f $MOUNT &
 359         UMOUNT_PID=$!
 360         sleep 6
 361         echo "killing umount"
 362         kill -TERM $UMOUNT_PID
 363         echo "waiting for umount to finish"
 364         wait $UMOUNT_PID
 365         if grep " $MOUNT " /proc/mounts; then
 366                 echo "test 5: /proc/mounts after failed umount"
 367                 umount -f $MOUNT &
 368                 UMOUNT_PID=$!
 369                 sleep 2
 370                 echo "killing umount"
 371                 kill -TERM $UMOUNT_PID
 372                 echo "waiting for umount to finish"
 373                 wait $UMOUNT_PID
 374                 grep " $MOUNT " /proc/mounts &&
 375                         error "/proc/mounts after second umount"
 376         fi
 377
 378         # manual_mount_client may fail due to umount succeeding above
 379         manual_umount_client
 380         # stop_mds is a no-op here, and should not fail
 381         cleanup_nocli || error "cleanup_nocli failed with $?"
 382         # df may have lingering entry
 383         manual_umount_client
 384         # mtab may have lingering entry
 385         local WAIT=0
 386         local MAX_WAIT=20
 387         local sleep=1
 388         while [ "$WAIT" -ne "$MAX_WAIT" ]; do
 389                 sleep $sleep
 390                 grep -q $MOUNT" " /etc/mtab || break
 391                 echo "Waiting /etc/mtab updated ... "
 392                 WAIT=$(( WAIT + sleep))
 393         done
 394         [ "$WAIT" -eq "$MAX_WAIT" ] &&
 395                 error "/etc/mtab is not updated in $WAIT secs"
 396         echo "/etc/mtab updated in $WAIT secs"
 397 }
 398 run_test 5a "force cleanup mds, then cleanup"
 399
 400 cleanup_5b () {
 401         trap 0
 402         start_mgs
 403 }
 404
 405 test_5b() {
 406         grep " $MOUNT " /etc/mtab &&
 407                 error false "unexpected entry in mtab before mount" && return 10
 408
 409         start_ost || error "OST start failed"
 410         if ! combined_mgs_mds ; then
 411                 trap cleanup_5b EXIT ERR
 412                 start_mds || error "MDS start failed"
 413                 stop mgs
 414         fi
 415
 416         mount_client $MOUNT && error "mount_client $MOUNT should fail"
 417         grep " $MOUNT " /etc/mtab &&
 418                 error "$MOUNT entry in mtab after failed mount"
 419         umount_client $MOUNT
 420         # stop_mds is a no-op here, and should not fail
 421         cleanup_nocli || error "cleanup_nocli failed with $?"
 422         if ! combined_mgs_mds ; then
 423                 cleanup_5b
 424         fi
 425 }
 426 run_test 5b "Try to start a client with no MGS (should return errs)"
 427
 428 test_5c() {
 429         grep " $MOUNT " /etc/mtab &&
 430                 error false "unexpected entry in mtab before mount" && return 10
 431
 432         start_mds || error "MDS start failed"
 433         start_ost || error "OST start failed"
 434         local oldfs="${FSNAME}"
 435         FSNAME="wrong.${FSNAME}"
 436         mount_client $MOUNT || :
 437         FSNAME=${oldfs}
 438         grep " $MOUNT " /etc/mtab &&
 439                 error "$MOUNT entry in mtab after failed mount"
 440         umount_client $MOUNT
 441         cleanup_nocli || error "cleanup_nocli failed with $?"
 442 }
 443 run_test 5c "cleanup after failed mount (bug 2712) (should return errs)"
 444
 445 test_5d() {
 446         grep " $MOUNT " /etc/mtab &&
 447                 error "unexpected entry in mtab before mount"
 448
 449         start_ost || error "OST start failed"
 450         start_mds || error "MDS start failed"
 451         stop_ost -f || error "Unable to stop OST1"
 452         mount_client $MOUNT || error "mount_client $MOUNT failed"
 453         umount_client $MOUNT -f || error "umount_client $MOUNT failed"
 454         cleanup_nocli || error "cleanup_nocli failed with $?"
 455         ! grep " $MOUNT " /etc/mtab ||
 456                 error "$MOUNT entry in mtab after unmount"
 457 }
 458 run_test 5d "mount with ost down"
 459
 460 test_5e() {
 461         grep " $MOUNT " /etc/mtab &&
 462                 error false "unexpected entry in mtab before mount" && return 10
 463
 464         start_mds || error "MDS start failed"
 465         start_ost || error "OST start failed"
 466
 467         #define OBD_FAIL_PTLRPC_DELAY_SEND       0x506
 468         do_facet client "$LCTL set_param fail_loc=0x80000506"
 469         mount_client $MOUNT || echo "mount failed (not fatal)"
 470         cleanup || error "cleanup failed with $?"
 471         grep " $MOUNT " /etc/mtab &&
 472                 error "$MOUNT entry in mtab after unmount"
 473         pass
 474 }
 475 run_test 5e "delayed connect, don't crash (bug 10268)"
 476
 477 test_5f() {
 478         combined_mgs_mds && skip "needs separate mgs and mds"
 479
 480         grep " $MOUNT " /etc/mtab &&
 481                 error false "unexpected entry in mtab before mount" && return 10
 482
 483         local rc=0
 484         start_ost || error "OST start failed"
 485         mount_client $MOUNT &
 486         local pid=$!
 487         echo client_mount pid is $pid
 488
 489         sleep 5
 490
 491         if ! ps -f -p $pid >/dev/null; then
 492                 wait $pid
 493                 rc=$?
 494                 grep " $MOUNT " /etc/mtab && echo "test 5f: mtab after mount"
 495                 error "mount returns $rc, expected to hang"
 496                 rc=11
 497                 cleanup || error "cleanup failed with $?"
 498                 return $rc
 499         fi
 500
 501         # start mds
 502         start_mds || error "start MDS failed"
 503
 504         # mount should succeed after start mds
 505         wait $pid
 506         grep " $MOUNT " /etc/mtab && echo "test 5f: mtab after mount"
 507         cleanup || error "final call to cleanup failed with rc $?"
 508 }
 509 run_test 5f "mds down, cleanup after failed mount (bug 2712)"
 510
 511 test_5g() {
 512         modprobe lustre
 513         [ "$CLIENT_VERSION" -lt $(version_code 2.9.53) ] &&
 514                 skip "automount of debugfs missing before 2.9.53"
 515         umount /sys/kernel/debug
 516         $LCTL get_param -n devices | egrep -v "error" && \
 517                 error "lctl can't access debugfs data"
 518         grep " debugfs " /etc/mtab || error "debugfs failed to remount"
 519 }
 520 run_test 5g "handle missing debugfs"
 521
 522 test_5h() {
 523         setup
 524
 525         stop mds1
 526         #define OBD_FAIL_MDS_FS_SETUP            0x135
 527         do_facet mds1 "$LCTL set_param fail_loc=0x80000135"
 528         start_mdt 1 && error "start mdt should fail"
 529         start_mdt 1 || error "start mdt failed"
 530         client_up || error "client_up failed"
 531         cleanup
 532 }
 533 run_test 5h "start mdt failure at mdt_fs_setup()"
 534
 535 test_5i() {
 536         (( $MDS1_VERSION >= $(version_code 2.12.54) )) ||
 537                 skip "Need MDS version at least 2.12.54"
 538
 539         setup
 540
 541         stop mds1
 542         #define OBD_FAIL_QUOTA_INIT              0xA05
 543         do_facet mds1 "$LCTL set_param fail_loc=0x80000A05"
 544         start_mdt 1 && error "start mdt should fail"
 545         start_mdt 1 || error "start mdt failed"
 546         client_up || error "client_up failed"
 547         cleanup
 548 }
 549 run_test 5i "start mdt failure at mdt_quota_init()"
 550
 551 test_5j() {
 552         unload_modules
 553         load_module ../libcfs/libcfs/libcfs ||
 554                 error "Failed to load modules libcfs rc = $?"
 555         $LCTL set_param debug=all
 556         rmmod -v libcfs
 557 }
 558 run_test 5j "verify libcfs doesn't crash when setting debug flags"
 559
 560 test_6() {
 561         setup
 562         manual_umount_client
 563         mount_client $MOUNT || error "mount_client $MOUNT failed"
 564         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 565         cleanup || error "cleanup failed with rc $?"
 566 }
 567 run_test 6 "manual umount, then mount again"
 568
 569 test_7() {
 570         setup
 571         manual_umount_client
 572         cleanup_nocli || error "cleanup_nocli failed with $?"
 573 }
 574 run_test 7 "manual umount, then cleanup"
 575
 576 test_8() {
 577         setup
 578         mount_client $MOUNT2 || error "mount_client $MOUNT2 failed"
 579         check_mount2 || error "check_mount2 failed"
 580         umount_client $MOUNT2 || error "umount_client $MOUNT2 failed"
 581         cleanup || error "cleanup failed with rc $?"
 582 }
 583 run_test 8 "double mount setup"
 584
 585 test_9() {
 586         start_ost || error "OST start failed"
 587
 588         do_facet ost1 $LCTL set_param debug=\'inode trace\' ||
 589                 error "do_facet ost1 set_param inode trace failed."
 590         do_facet ost1 $LCTL set_param subsystem_debug=\'mds ost\' ||
 591                 error "do_facet ost1 set_param debug mds ost failed."
 592
 593         CHECK_PTLDEBUG="`do_facet ost1 $LCTL get_param -n debug`"
 594         if [ "$CHECK_PTLDEBUG" ] && { \
 595            [ "$CHECK_PTLDEBUG" = "trace inode warning error emerg console" ] ||
 596            [ "$CHECK_PTLDEBUG" = "trace inode" ]; }; then
 597                 echo "lnet.debug success"
 598         else
 599                 error "lnet.debug: want 'trace inode', have '$CHECK_PTLDEBUG'"
 600         fi
 601         CHECK_SUBSYS="`do_facet ost1 $LCTL get_param -n subsystem_debug`"
 602         if [ "$CHECK_SUBSYS" ] && [ "$CHECK_SUBSYS" = "mds ost" ]; then
 603                 echo "lnet.subsystem_debug success"
 604         else
 605                 error "lnet.subsystem_debug: want 'mds ost' got '$CHECK_SUBSYS'"
 606         fi
 607         stop_ost || error "Unable to stop OST1"
 608 }
 609 run_test 9 "test ptldebug and subsystem for mkfs"
 610
 611 test_10a() {
 612         setup
 613
 614         if ! combined_mgs_mds; then
 615                 files=$(do_facet mgs "find /{proc/fs,sys/fs,sys/kernel/debug}/lustre -type l -exec test ! -e {} \; -print")
 616                 [ -z $files ] || echo "MGS $files is a broken symlink"
 617         fi
 618
 619         files=$(do_facet mds1 "find /{proc/fs,sys/fs,sys/kernel/debug}/lustre -type l -exec test ! -e {} \; -print")
 620         [ -z $files ] || echo "MDS $files is a broken symlink"
 621
 622         files=$(do_facet ost1 "find /{proc/fs,sys/fs,sys/kernel/debug}/lustre -type l -exec test ! -e {} \; -print")
 623         [ -z $files ] || echo "OSS $files is a broken symlink"
 624
 625         files=$(do_facet client "find /{proc/fs,sys/fs,sys/kernel/debug}/lustre -type l -exec test ! -e {} \; -print")
 626         [ -z $files ] || echo "clients $files is a broken symlink"
 627
 628         cleanup || error "cleanup failed with rc $?"
 629 }
 630 run_test 10a "find lctl param broken symlinks"
 631
 632 #
 633 # Test 16 was to "verify that lustre will correct the mode of OBJECTS".
 634 # But with new MDS stack we don't care about the mode of local objects
 635 # anymore, so this test is removed. See bug 22944 for more details.
 636 #
 637
 638 test_17() {
 639         if [ "$mds1_FSTYPE" != ldiskfs ]; then
 640                 skip "ldiskfs only test"
 641         fi
 642
 643         setup
 644         check_mount || error "check_mount failed"
 645         cleanup || error "cleanup failed with rc $?"
 646
 647         echo "Remove mds config log"
 648         if ! combined_mgs_mds ; then
 649                 stop mgs
 650         fi
 651
 652         do_facet mgs "$DEBUGFS -w -R 'unlink CONFIGS/$FSNAME-MDT0000' \
 653                       $(mgsdevname) || return \$?" ||
 654                 error "do_facet mgs failed with $?"
 655
 656         if ! combined_mgs_mds ; then
 657                 start_mgs
 658         fi
 659
 660         start_ost || error "OST start failed"
 661         start_mds && error "MDS start succeeded, but should fail"
 662         reformat_and_config
 663 }
 664 run_test 17 "Verify failed mds_postsetup won't fail assertion (2936) (should return errs)"
 665
 666 test_18() {
 667         if [ "$mds1_FSTYPE" != ldiskfs ]; then
 668                 skip "ldiskfs only test"
 669         fi
 670
 671         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
 672
 673         local MIN=2000000
 674
 675         local OK=
 676         # check if current MDSSIZE is large enough
 677         [ $MDSSIZE -ge $MIN ] && OK=1 && myMDSSIZE=$MDSSIZE &&
 678                 log "use MDSSIZE=$MDSSIZE"
 679
 680         # check if the global config has a large enough MDSSIZE
 681         [ -z "$OK" -a ! -z "$STORED_MDSSIZE" ] &&
 682                 [ $STORED_MDSSIZE -ge $MIN ] &&
 683                 OK=1 && myMDSSIZE=$STORED_MDSSIZE &&
 684                 log "use STORED_MDSSIZE=$STORED_MDSSIZE"
 685
 686         # check if the block device is large enough
 687         is_blkdev $SINGLEMDS $MDSDEV $MIN
 688         local large_enough=$?
 689         if [ -n "$OK" ]; then
 690                 [ $large_enough -ne 0 ] && OK=""
 691         else
 692                 [ $large_enough -eq 0 ] && OK=1 && myMDSSIZE=$MIN &&
 693                         log "use device $MDSDEV with MIN=$MIN"
 694         fi
 695
 696         # check if a loopback device has enough space for fs metadata (5%)
 697
 698         if [ -z "$OK" ]; then
 699                 local SPACE=$(do_facet $SINGLEMDS "[ -f $MDSDEV -o ! \
 700                               -e $MDSDEV ] && df -P \\\$(dirname $MDSDEV)" |
 701                         awk '($1 != "Filesystem") { print $4 }')
 702                 ! [ -z "$SPACE" ] && [ $SPACE -gt $((MIN / 20)) ] &&
 703                         OK=1 && myMDSSIZE=$MIN &&
 704                         log "use file $MDSDEV with MIN=$MIN"
 705         fi
 706
 707         [ -z "$OK" ] && skip_env "$MDSDEV too small for ${MIN}kB MDS"
 708
 709         echo "mount mds with large journal..."
 710
 711         local OLD_MDSSIZE=$MDSSIZE
 712         MDSSIZE=$myMDSSIZE
 713
 714         reformat_and_config
 715         echo "mount lustre system..."
 716         setup
 717         check_mount || error "check_mount failed"
 718
 719         echo "check journal size..."
 720         local FOUNDSIZE=$(do_facet $SINGLEMDS "$DEBUGFS -c -R 'stat <8>' $MDSDEV" | awk '/Size: / { print $NF; exit;}')
 721         if [ $FOUNDSIZE -gt $((32 * 1024 * 1024)) ]; then
 722                 log "Success: mkfs creates large journals. Size: $((FOUNDSIZE >> 20))M"
 723         else
 724                 error "expected journal size > 32M, found $((FOUNDSIZE >> 20))M"
 725         fi
 726
 727         cleanup || error "cleanup failed with rc $?"
 728
 729         MDSSIZE=$OLD_MDSSIZE
 730         reformat_and_config
 731 }
 732 run_test 18 "check mkfs creates large journals"
 733
 734 test_19a() {
 735         start_mds || error "MDS start failed"
 736         stop_mds || error "Unable to stop MDS"
 737 }
 738 run_test 19a "start/stop MDS without OSTs"
 739
 740 test_19b() {
 741         start_ost || error "Unable to start OST1"
 742         stop_ost -f || error "Unable to stop OST1"
 743 }
 744 run_test 19b "start/stop OSTs without MDS"
 745
 746 test_20() {
 747         # first format the ost/mdt
 748         start_mds || error "MDS start failed"
 749         start_ost || error "Unable to start OST1"
 750         mount_client $MOUNT || error "mount_client $MOUNT failed"
 751         check_mount || error "check_mount failed"
 752         rm -f $DIR/$tfile || error "remove $DIR/$tfile failed."
 753         mount_client $MOUNT remount,ro || error "remount client with ro failed"
 754         touch $DIR/$tfile && error "$DIR/$tfile created incorrectly"
 755         [ -e $DIR/$tfile ] && error "$DIR/$tfile exists incorrectly"
 756         mount_client $MOUNT remount,rw || error "remount client with rw failed"
 757         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
 758         MCNT=$(grep -c $MOUNT' ' /etc/mtab)
 759         [ "$MCNT" -ne 1 ] && error "$MOUNT in /etc/mtab $MCNT times"
 760         umount_client $MOUNT
 761         stop_mds || error "Unable to stop MDS"
 762         stop_ost || error "Unable to stop OST1"
 763 }
 764 run_test 20 "remount ro,rw mounts work and doesn't break /etc/mtab"
 765
 766 test_21a() {
 767         start_mds || error "MDS start failed"
 768         start_ost || error "unable to start OST1"
 769         wait_osc_import_state mds ost FULL
 770         stop_ost || error "unable to stop OST1"
 771         stop_mds || error "unable to stop MDS"
 772 }
 773 run_test 21a "start mds before ost, stop ost first"
 774
 775 test_21b() {
 776         start_ost || error "unable to start OST1"
 777         start_mds || error "MDS start failed"
 778         wait_osc_import_state mds ost FULL
 779         stop_mds || error "unable to stop MDS"
 780         stop_ost || error "unable to stop OST1"
 781 }
 782 run_test 21b "start ost before mds, stop mds first"
 783
 784 test_21c() {
 785         start_ost || error "Unable to start OST1"
 786         start_mds || error "MDS start failed"
 787         start_ost2 || error "Unable to start OST2"
 788         wait_osc_import_state mds ost2 FULL
 789         stop_ost || error "Unable to stop OST1"
 790         stop_ost2 || error "Unable to stop OST2"
 791         stop_mds || error "Unable to stop MDS"
 792         #writeconf to remove all ost2 traces for subsequent tests
 793         writeconf_or_reformat
 794 }
 795 run_test 21c "start mds between two osts, stop mds last"
 796
 797 test_21d() {
 798         combined_mgs_mds && skip "need separate mgs device"
 799
 800         stopall
 801         reformat
 802
 803         start_mgs || error "unable to start MGS"
 804         start_ost || error "unable to start OST1"
 805         start_ost2 || error "unable to start OST2"
 806         start_mds || error "MDS start failed"
 807         wait_osc_import_state mds ost2 FULL
 808
 809         local zkeeper=${KEEP_ZPOOL}
 810         stack_trap "KEEP_ZPOOL=$zkeeper" EXIT
 811         KEEP_ZPOOL="true"
 812
 813         stop_ost || error "Unable to stop OST1"
 814         stop_ost2 || error "Unable to stop OST2"
 815         stop_mds || error "Unable to stop MDS"
 816         stop_mgs
 817         #writeconf to remove all ost2 traces for subsequent tests
 818         writeconf_or_reformat
 819         KEEP_ZPOOL="${zkeeper}"
 820
 821         start_mgs || error "unable to start MGS"
 822 }
 823 run_test 21d "start mgs then ost and then mds"
 824
 825 cleanup_21e() {
 826         MGSNID="$saved_mgsnid"
 827         cleanup_fs2
 828         echo "stopping fs2mgs ..."
 829         stop $fs2mgs -f || true
 830 }
 831
 832 test_21e() { # LU-5863
 833         if [[ -z "$fs3ost_DEV" || -z "$fs2ost_DEV" || -z "$fs2mds_DEV" ]]; then
 834                 is_blkdev $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) &&
 835                 skip_env "mixed loopback and real device not working"
 836         fi
 837
 838         local fs2mdsdev=$(mdsdevname 1_2)
 839         local fs2ostdev=$(ostdevname 1_2)
 840         local fs3ostdev=$(ostdevname 2_2)
 841
 842         local fs2mdsvdev=$(mdsvdevname 1_2)
 843         local fs2ostvdev=$(ostvdevname 1_2)
 844         local fs3ostvdev=$(ostvdevname 2_2)
 845
 846         # temporarily use fs3ost as fs2mgs
 847         local fs2mgs=fs3ost
 848         local fs2mgsdev=$fs3ostdev
 849         local fs2mgsvdev=$fs3ostvdev
 850
 851         local fsname=test1234
 852
 853         add $fs2mgs $(mkfs_opts mgs $fs2mgsdev) --fsname=$fsname \
 854                 --reformat $fs2mgsdev $fs2mgsvdev || error "add fs2mgs failed"
 855         start $fs2mgs $fs2mgsdev $MGS_MOUNT_OPTS && trap cleanup_21e EXIT INT ||
 856                 error "start fs2mgs failed"
 857
 858         local saved_mgsnid="$MGSNID"
 859         MGSNID=$(do_facet $fs2mgs $LCTL list_nids | xargs | tr ' ' ,)
 860
 861         add fs2mds $(mkfs_opts mds1 $fs2mdsdev $fsname) \
 862                 --reformat $fs2mdsdev $fs2mdsvdev || error "add fs2mds failed"
 863         add fs2ost $(mkfs_opts ost1 $fs2ostdev $fsname) \
 864                 --reformat $fs2ostdev $fs2ostvdev || error "add fs2ost failed"
 865
 866         start fs2ost $fs2ostdev $OST_MOUNT_OPTS || error "start fs2ost failed"
 867         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS || error "start fs2mds failed"
 868
 869         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
 870         $MOUNT_CMD $MGSNID:/$fsname $MOUNT2 || error "mount $MOUNT2 failed"
 871         DIR=$MOUNT2 MOUNT=$MOUNT2 check_mount || error "check $MOUNT2 failed"
 872
 873         cleanup_21e
 874 }
 875 run_test 21e "separate MGS and MDS"
 876
 877 test_22() {
 878         start_mds || error "MDS start failed"
 879
 880         echo "Client mount with ost in logs, but none running"
 881         start_ost || error "unable to start OST1"
 882         # wait until mds connected to ost and open client connection
 883         wait_osc_import_state mds ost FULL
 884         stop_ost || error "unable to stop OST1"
 885         mount_client $MOUNT || error "mount_client $MOUNT failed"
 886         # check_mount will block trying to contact ost
 887         mcreate $DIR/$tfile || error "mcreate $DIR/$tfile failed"
 888         rm -f $DIR/$tfile || error "remove $DIR/$tfile failed"
 889         umount_client $MOUNT -f
 890         pass
 891
 892         echo "Client mount with a running ost"
 893         start_ost || error "unable to start OST1"
 894         if $GSS; then
 895                 # if gss enabled, wait full time to let connection from
 896                 # mds to ost be established, due to the mismatch between
 897                 # initial connect timeout and gss context negotiation timeout.
 898                 # This perhaps could be remove after AT landed.
 899                 echo "sleep $((TIMEOUT + TIMEOUT + TIMEOUT))s"
 900                 sleep $((TIMEOUT + TIMEOUT + TIMEOUT))
 901         fi
 902         mount_client $MOUNT || error "mount_client $MOUNT failed"
 903         wait_osc_import_state mds ost FULL
 904         wait_osc_import_ready client ost
 905         check_mount || error "check_mount failed"
 906         pass
 907
 908         cleanup || error "cleanup failed with rc $?"
 909 }
 910 run_test 22 "start a client before osts (should return errs)"
 911
 912 test_23a() {    # was test_23
 913         setup
 914         # fail mds
 915         stop $SINGLEMDS || error "failed to stop $SINGLEMDS"
 916         # force down client so that recovering mds waits for reconnect
 917         local running=$(grep -c $MOUNT /proc/mounts) || true
 918         if [ $running -ne 0 ]; then
 919                 echo "Stopping client $MOUNT (opts: -f)"
 920                 umount -f $MOUNT
 921         fi
 922
 923         # enter recovery on failed mds
 924         local MDT_DEV=$(mdsdevname ${SINGLEMDS//mds/})
 925         start $SINGLEMDS $MDT_DEV $MDS_MOUNT_OPTS || error "MDS start failed"
 926         # try to start a new client
 927         mount_client $MOUNT &
 928         sleep 5
 929         MOUNT_PID=$(ps -ef | grep "t lustre" | grep -v grep | awk '{print $2}')
 930         MOUNT_LUSTRE_PID=$(ps -ef | grep mount.lustre |
 931                            grep -v grep | awk '{print $2}')
 932         echo mount pid is ${MOUNT_PID}, mount.lustre pid is ${MOUNT_LUSTRE_PID}
 933         ps --ppid $MOUNT_PID
 934         ps --ppid $MOUNT_LUSTRE_PID
 935         echo "waiting for mount to finish"
 936         ps -ef | grep mount
 937         # "ctrl-c" sends SIGINT but it usually (in script) does not work on child process
 938         # SIGTERM works but it does not spread to offspring processses
 939         kill -s TERM $MOUNT_PID
 940         kill -s TERM $MOUNT_LUSTRE_PID
 941         # we can not wait $MOUNT_PID because it is not a child of this shell
 942         local PID1
 943         local PID2
 944         local WAIT=0
 945         local MAX_WAIT=30
 946         local sleep=1
 947         while [ "$WAIT" -lt "$MAX_WAIT" ]; do
 948                 sleep $sleep
 949                 PID1=$(ps -ef | awk '{print $2}' | grep -w $MOUNT_PID)
 950                 PID2=$(ps -ef | awk '{print $2}' | grep -w $MOUNT_LUSTRE_PID)
 951                 echo PID1=$PID1
 952                 echo PID2=$PID2
 953                 [ -z "$PID1" -a -z "$PID2" ] && break
 954                 echo "waiting for mount to finish ... "
 955                 WAIT=$(( WAIT + sleep))
 956         done
 957         if [ "$WAIT" -eq "$MAX_WAIT" ]; then
 958                 error "MOUNT_PID $MOUNT_PID and "\
 959                 "MOUNT_LUSTRE_PID $MOUNT_LUSTRE_PID still not killed in $WAIT secs"
 960                 ps -ef | grep mount
 961         fi
 962         cleanup || error "cleanup failed with rc $?"
 963 }
 964 run_test 23a "interrupt client during recovery mount delay"
 965
 966 test_23b() {    # was test_23
 967         start_mds || error "MDS start failed"
 968         start_ost || error "Unable to start OST1"
 969         # Simulate -EINTR during mount OBD_FAIL_LDLM_CLOSE_THREAD
 970         $LCTL set_param fail_loc=0x80000313
 971         mount_client $MOUNT
 972         cleanup || error "cleanup failed with rc $?"
 973 }
 974 run_test 23b "Simulate -EINTR during mount"
 975
 976 test_24a() {
 977         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
 978
 979         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" ]; then
 980                 is_blkdev $SINGLEMDS $MDSDEV &&
 981                 skip_env "mixed loopback and real device not working"
 982         fi
 983
 984         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST
 985
 986         local fs2mdsdev=$(mdsdevname 1_2)
 987         local fs2ostdev=$(ostdevname 1_2)
 988         local fs2mdsvdev=$(mdsvdevname 1_2)
 989         local fs2ostvdev=$(ostvdevname 1_2)
 990         local cl_user
 991
 992         # LU-9733 test fsname started with numbers as well
 993         local FSNAME2=969362ae
 994
 995         add fs2mds $(mkfs_opts mds1 ${fs2mdsdev} ) --nomgs --mgsnode=$MGSNID \
 996                 --fsname=${FSNAME2} --reformat $fs2mdsdev $fs2mdsvdev || exit 10
 997
 998         add fs2ost $(mkfs_opts ost1 ${fs2ostdev}) --fsname=${FSNAME2} \
 999                 --reformat $fs2ostdev $fs2ostvdev || exit 10
1000
1001         setup
1002         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && trap cleanup_fs2 EXIT INT
1003         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
1004         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
1005         $MOUNT_CMD $MGSNID:/${FSNAME2} $MOUNT2 || error "$MOUNT_CMD failed"
1006
1007         # LU-9733 test fsname started with numbers
1008         cl_user=$(do_facet $SINGLEMDS lctl --device $FSNAME2-MDT0000 \
1009                         changelog_register -n) ||
1010                                 error "register changelog failed"
1011
1012         do_facet $SINGLEMDS lctl --device $FSNAME2-MDT0000 \
1013                         changelog_deregister $cl_user ||
1014                                 error "deregister changelog failed"
1015         # 1 still works
1016         check_mount || error "check_mount failed"
1017         # files written on 1 should not show up on 2
1018         cp /etc/passwd $DIR/$tfile
1019         sleep 10
1020         [ -e $MOUNT2/$tfile ] && error "File bleed"
1021         # 2 should work
1022         sleep 5
1023         cp /etc/passwd $MOUNT2/$tfile ||
1024                 error "cp /etc/passwd $MOUNT2/$tfile failed"
1025         rm $MOUNT2/$tfile || error "remove $MOUNT2/$tfile failed"
1026         # 2 is actually mounted
1027         grep $MOUNT2' ' /proc/mounts > /dev/null || error "$MOUNT2 not mounted"
1028         # failover
1029         facet_failover fs2mds
1030         facet_failover fs2ost
1031         df
1032         umount_client $MOUNT
1033         # the MDS must remain up until last MDT
1034         stop_mds
1035         MDS=$(do_facet $SINGLEMDS "$LCTL get_param -n devices" |
1036               awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }' | head -1)
1037         [ -z "$MDS" ] && error "No MDT"
1038         cleanup_fs2
1039         cleanup_nocli || error "cleanup_nocli failed with rc $?"
1040 }
1041 run_test 24a "Multiple MDTs on a single node"
1042
1043 test_24b() {
1044         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
1045         combined_mgs_mds ||
1046                 skip "needs combined MGT and MDT device"
1047
1048         if [ -z "$fs2mds_DEV" ]; then
1049                 local dev=${SINGLEMDS}_dev
1050                 local MDSDEV=${!dev}
1051                 is_blkdev $SINGLEMDS $MDSDEV &&
1052                 skip_env "mixed loopback and real device not working"
1053         fi
1054
1055         local fs2mdsdev=$(mdsdevname 1_2)
1056         local fs2mdsvdev=$(mdsvdevname 1_2)
1057
1058         add fs2mds $(mkfs_opts mds1 ${fs2mdsdev} ) --mgs --fsname=${FSNAME}2 \
1059                 --reformat $fs2mdsdev $fs2mdsvdev || exit 10
1060         setup
1061         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && {
1062                 cleanup
1063                 error "start MDS should fail"
1064         }
1065         stop fs2mds -f
1066         cleanup || error "cleanup failed with rc $?"
1067 }
1068 run_test 24b "Multiple MGSs on a single node (should return err)"
1069
1070 test_25() {
1071         setup_noconfig
1072         check_mount || error "check_mount failed"
1073         local MODULES=$($LCTL modules | awk '{ print $2 }')
1074         rmmod $MODULES 2>/dev/null || true
1075         cleanup || error "cleanup failed with $?"
1076 }
1077 run_test 25 "Verify modules are referenced"
1078
1079 test_26() {
1080         load_modules
1081         # we need modules before mount for sysctl, so make sure...
1082         do_facet $SINGLEMDS "lsmod | grep -q lustre || modprobe lustre"
1083         #define OBD_FAIL_MDS_FS_SETUP            0x135
1084         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x80000135"
1085         start_mds && error "MDS started but should not have started"
1086         $LCTL get_param -n devices
1087         DEVS=$($LCTL get_param -n devices | egrep -v MG | wc -l)
1088         [ $DEVS -gt 0 ] && error "number of devices is $DEVS, should be zero"
1089         # start mds to drop writeconf setting
1090         start_mds || error "Unable to start MDS"
1091         stop_mds || error "Unable to stop MDS"
1092         unload_modules_conf || error "unload_modules_conf failed with $?"
1093 }
1094 run_test 26 "MDT startup failure cleans LOV (should return errs)"
1095
1096 test_27a() {
1097         cleanup
1098         start_ost || error "Unable to start OST1"
1099         start_mds || error "Unable to start MDS"
1100         echo "Requeue thread should have started: "
1101         ps -e | grep ll_cfg_requeue
1102         set_persistent_param_and_check ost1                     \
1103            "obdfilter.$FSNAME-OST0000.client_cache_seconds"     \
1104            "$FSNAME-OST0000.ost.client_cache_seconds"
1105         cleanup_nocli || error "cleanup_nocli failed with rc $?"
1106 }
1107 run_test 27a "Reacquire MGS lock if OST started first"
1108
1109 test_27b() {
1110         # FIXME. ~grev
1111         setup_noconfig
1112         local device=$(do_facet $SINGLEMDS "$LCTL get_param -n devices" |
1113                         awk '($3 ~ "mdt" && $4 ~ "MDT0000") { print $4 }')
1114
1115         facet_failover $SINGLEMDS
1116         set_persistent_param_and_check $SINGLEMDS       \
1117                 "mdt.$device.identity_acquire_expire"   \
1118                 "$device.mdt.identity_acquire_expire"
1119         set_persistent_param_and_check client           \
1120                 "mdc.$device-mdc-*.max_rpcs_in_flight"  \
1121                 "$device.mdc.max_rpcs_in_flight"
1122         check_mount
1123         cleanup || error "cleanup failed with $?"
1124 }
1125 run_test 27b "Reacquire MGS lock after failover"
1126
1127 test_28A() { # was test_28
1128         setup_noconfig
1129
1130         local TEST="llite.$FSNAME-*.max_read_ahead_whole_mb"
1131         local PARAM="$FSNAME.llite.max_read_ahead_whole_mb"
1132         local orig=$($LCTL get_param -n $TEST)
1133         local max=$($LCTL get_param -n \
1134                         llite.$FSNAME-*.max_read_ahead_per_file_mb)
1135
1136         orig=${orig%%.[0-9]*}
1137         max=${max%%.[0-9]*}
1138         echo "ORIG:$orig MAX:$max"
1139         [[ $max -le $orig ]] && orig=$((max - 3))
1140         echo "ORIG:$orig MAX:$max"
1141
1142         local final=$((orig + 1))
1143
1144         set_persistent_param_and_check client "$TEST" "$PARAM" $final
1145         final=$((final + 1))
1146         set_persistent_param_and_check client "$TEST" "$PARAM" $final
1147         umount_client $MOUNT || error "umount_client $MOUNT failed"
1148         mount_client $MOUNT || error "mount_client $MOUNT failed"
1149
1150         local result=$($LCTL get_param -n $TEST)
1151
1152         if [ $result -ne $final ]; then
1153                 error "New config not seen: wanted $final got $result"
1154         else
1155                 echo "New config success: got $result"
1156         fi
1157         set_persistent_param_and_check client "$TEST" "$PARAM" $orig
1158         cleanup || error "cleanup failed with rc $?"
1159 }
1160 run_test 28A "permanent parameter setting"
1161
1162 test_28a() { # LU-4221
1163         [[ "$OST1_VERSION" -ge $(version_code 2.5.52) ]] ||
1164                 skip "Need OST version at least 2.5.52"
1165         [ "$ost1_FSTYPE" = zfs ] &&
1166                 skip "LU-4221: no such proc params for ZFS OSTs"
1167
1168         local name
1169         local param
1170         local cmd
1171         local old
1172         local new
1173         local device="$FSNAME-OST0000"
1174
1175         setup_noconfig
1176
1177         # In this test we will set three kinds of proc parameters with
1178         # lctl set_param -P or lctl conf_param:
1179         # 1. non-symlink ones in the OFD
1180         # 2. non-symlink ones in the OSD
1181
1182         # Check 1.
1183         # prepare a non-symlink parameter in the OFD
1184         name="client_cache_seconds"
1185         param="$device.ost.$name"
1186         cmd="obdfilter.$device.$name"
1187
1188         # permanently setting the parameter in the OFD
1189         old=$(do_facet ost1 $LCTL get_param -n $cmd)
1190         new=$((old * 2))
1191         set_persistent_param_and_check ost1 "$cmd" "$param" $new
1192         set_persistent_param_and_check ost1 "$cmd" "$param" $old
1193
1194         # Check 2.
1195         # prepare a non-symlink parameter in the OSD
1196         name="auto_scrub"
1197         param="$device.osd.$name"
1198         cmd="osd-*.$device.$name"
1199
1200         # conf_param the parameter in the OSD
1201         old=$(do_facet ost1 $LCTL get_param -n $cmd)
1202         new=$(((old + 1) % 2))
1203         set_persistent_param_and_check ost1 "$cmd" "$param" $new
1204         set_persistent_param_and_check ost1 "$cmd" "$param" $old
1205
1206         cleanup || error "cleanup failed with $?"
1207 }
1208 run_test 28a "set symlink parameters permanently with lctl"
1209
1210 test_29() {
1211         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >= 2 OSTs"
1212         setup_noconfig > /dev/null 2>&1
1213         start_ost2 || error "Unable to start OST2"
1214         sleep 10
1215
1216         local PARAM="$FSNAME-OST0001.osc.active"
1217         # With lctl set_param -P the value $PROC_ACT will be sent to
1218         # all nodes. The [!M] filter out the ability to set active
1219         # on the MDS servers which is tested with wait_osp_* below.
1220         # For ost_server_uuid that only exist on client so filtering
1221         # is safe.
1222         local PROC_ACT="os[cp].$FSNAME-OST0001-osc-[^M]*.active"
1223         local PROC_UUID="os[cp].$FSNAME-OST0001-osc-[^M]*.ost_server_uuid"
1224
1225         ACTV=$($LCTL get_param -n $PROC_ACT)
1226         DEAC=$((1 - $ACTV))
1227         set_persistent_param_and_check client $PROC_ACT $PARAM $DEAC
1228         # also check ost_server_uuid status
1229         RESULT=$($LCTL get_param -n $PROC_UUID | grep DEACTIV)
1230         if [ -z "$RESULT" ]; then
1231                 error "Client not deactivated: $($LCTL get_param \
1232                        -n $PROC_UUID)"
1233         else
1234                 echo "Live client success: got $RESULT"
1235         fi
1236
1237         # check MDTs too
1238         wait_osp_active ost ${FSNAME}-OST0001 1 0
1239
1240         # test new client starts deactivated
1241         umount_client $MOUNT || error "umount_client $MOUNT failed"
1242         mount_client $MOUNT || error "mount_client $MOUNT failed"
1243
1244         # the 2nd and 3rd field of ost_server_uuid do not update at the same
1245         # time when using lctl set_param -P
1246         wait_update_facet client                                        \
1247                 "$LCTL get_param -n $PROC_UUID | awk '{print \\\$3 }'"  \
1248                 "DEACTIVATED" ||
1249                 error "New client start active: $($LCTL get_param -n $PROC_UUID)"
1250
1251         echo "New client success: got '$($LCTL get_param -n $PROC_UUID)'"
1252
1253         # make sure it reactivates
1254         set_persistent_param_and_check client $PROC_ACT $PARAM $ACTV
1255
1256         umount_client $MOUNT
1257         stop_ost2 || error "Unable to stop OST2"
1258         cleanup_nocli || error "cleanup_nocli failed with $?"
1259         #writeconf to remove all ost2 traces for subsequent tests
1260         writeconf_or_reformat
1261 }
1262 run_test 29 "permanently remove an OST"
1263
1264 test_30a() {
1265         setup_noconfig
1266
1267         echo Big config llog
1268         local path="llite.$FSNAME-*"
1269         local cpath="$FSNAME.llite"
1270         local param="max_read_ahead_whole_mb"
1271
1272         local test="${path}.$param"
1273         local conf="${cpath}.$param"
1274
1275         local orig=$($LCTL get_param -n $test)
1276         local list=(1 2 3 4 5 4 3 2 1 2 3 4 5 4 3 2 1 2 3 4 5)
1277         for i in ${list[@]}; do
1278                 set_persistent_param_and_check client $test $conf $i
1279         done
1280         # make sure client restart still works
1281         umount_client $MOUNT
1282         mount_client $MOUNT || error "mount_client $MOUNT failed"
1283         [ "$($LCTL get_param -n $test)" -ne "$i" ] &&
1284                 error "Param didn't stick across restart $($test) != $i"
1285         pass
1286
1287         echo Erase parameter setting
1288         if [[ $PERM_CMD == *"set_param -P"* ]]; then
1289                 do_facet mgs "$PERM_CMD -d $test" ||
1290                         error "Erase param $test failed"
1291         else
1292                 do_facet mgs "$PERM_CMD -d $conf" ||
1293                         error "Erase param $conf failed"
1294         fi
1295         umount_client $MOUNT
1296         mount_client $MOUNT || error "mount_client $MOUNT failed"
1297         local final=$($LCTL get_param -n $test)
1298         echo "deleted (default) value=$final, orig=$orig"
1299         orig=${orig%%.[0-9]*}
1300         final=${final%%.[0-9]*}
1301         # assumes this parameter started at the default value
1302         [ "$final" -eq "$orig" ] ||
1303                 error "Deleted value=$final -ne orig=$orig"
1304
1305         cleanup || error "cleanup failed with rc $?"
1306 }
1307 run_test 30a "Big config llog and permanent parameter deletion"
1308
1309 test_30b() {
1310         setup_noconfig
1311
1312         local orignids=$($LCTL get_param -n \
1313                 osc.$FSNAME-OST0000-osc-[^M]*.import | grep failover_nids)
1314
1315         local orignidcount=$(echo "$orignids" | wc -w)
1316
1317         # Make a fake nid.  Use the OST nid, and add 20 to the least significant
1318         # numerical part of it. Hopefully that's not already a failover address
1319         # for the server.
1320         local OSTNID=$(do_facet ost1 "$LCTL get_param nis" | tail -1 | \
1321                 awk '{print $1}')
1322         local ORIGVAL=$(echo $OSTNID | egrep -oi "[0-9]*@")
1323         local NEWVAL=$((($(echo $ORIGVAL | egrep -oi "[0-9]*") + 20) % 256))
1324         local NEW=$(echo $OSTNID | sed "s/$ORIGVAL/$NEWVAL@/")
1325         echo "Using fake nid $NEW"
1326
1327         local TEST="$LCTL get_param -n osc.$FSNAME-OST0000-osc-[^M]*.import |
1328                 grep failover_nids | sed -n 's/.*\($NEW\).*/\1/p'"
1329         if [[ $PERM_CMD == *"set_param -P"* ]]; then
1330                 PARAM="osc.$FSNAME-OST0000-osc-[^M]*.import"
1331                 echo "Setting $PARAM from $TEST to $NEW"
1332                 do_facet mgs "$PERM_CMD $PARAM='connection=$NEW'" ||
1333                         error "$PERM_CMD $PARAM failed"
1334         else
1335                 PARAM="$FSNAME-OST0000.failover.node"
1336                 echo "Setting $PARAM from $TEST to $NEW"
1337                 do_facet mgs "$PERM_CMD $PARAM='$NEW'" ||
1338                         error "$PARAM $PARAM failed"
1339         fi
1340         wait_update_facet client "$TEST" "$NEW" ||
1341                 error "check $PARAM failed!"
1342
1343         local NIDS=$($LCTL get_param -n osc.$FSNAME-OST0000-osc-[^M]*.import |
1344                 grep failover_nids)
1345         local NIDCOUNT=$(echo "$NIDS" | wc -w)
1346         echo "should have $((orignidcount + 1)) entries \
1347                 in failover nids string, have $NIDCOUNT"
1348         [ $NIDCOUNT -eq $((orignidcount + 1)) ] ||
1349                 error "Failover nid not added"
1350
1351         if [[ $PERM_CMD == *"set_param -P"* ]]; then
1352                 do_facet mgs "$PERM_CMD -d osc.$FSNAME-OST0000-osc-*.import"
1353         else
1354                 do_facet mgs "$PERM_CMD -d $FSNAME-OST0000.failover.node" ||
1355                         error "$PERM_CMD delete failed"
1356         fi
1357         umount_client $MOUNT
1358         mount_client $MOUNT || error "mount_client $MOUNT failed"
1359
1360         NIDS=$($LCTL get_param -n osc.$FSNAME-OST0000-osc-[^M]*.import |
1361                 grep failover_nids)
1362         NIDCOUNT=$(echo "$NIDS" | wc -w)
1363         echo "only $orignidcount final entries should remain \
1364                 in failover nids string, have $NIDCOUNT"
1365         [ $NIDCOUNT -eq $orignidcount ] || error "Failover nids not removed"
1366
1367         cleanup || error "cleanup failed with rc $?"
1368 }
1369 run_test 30b "Remove failover nids"
1370
1371 test_31() { # bug 10734
1372         # ipaddr must not exist
1373         $MOUNT_CMD 4.3.2.1@tcp:/lustre $MOUNT || true
1374         cleanup || error "cleanup failed with rc $?"
1375 }
1376 run_test 31 "Connect to non-existent node (shouldn't crash)"
1377
1378
1379 T32_QID=60000
1380 T32_BLIMIT=40960 # Kbytes
1381 T32_ILIMIT=4
1382 T32_PRJID=1000
1383 T32_PROLIMIT=$((T32_BLIMIT/10))
1384 #
1385 # This is not really a test but a tool to create new disk
1386 # image tarballs for the upgrade tests.
1387 #
1388 # Disk image tarballs should be created on single-node
1389 # clusters by running this test with default configurations
1390 # plus a few mandatory environment settings that are verified
1391 # at the beginning of the test.
1392 #
1393 test_32newtarball() {
1394         local version
1395         local dst=.
1396         local src=/etc/rc.d
1397         local tmp=$TMP/t32_image_create
1398         local remote_dir
1399         local striped_dir
1400         local pushd_dir
1401         local pfl_dir
1402         local pfl_file
1403         local dom_dir
1404         local dom_file
1405         local flr_dir
1406         local flr_file
1407         local pj_quota_dir
1408         local pj_quota_file_old
1409         local target_dir
1410
1411         if [ $FSNAME != t32fs -o \( -z "$MDSDEV" -a -z "$MDSDEV1" \) -o \
1412         $OSTCOUNT -ne 2 -o -z "$OSTDEV1" ]; then
1413                 error   "Needs FSNAME=t32fs MDSCOUNT=2 "                \
1414                         "MDSDEV1=<nonexistent_file> "                   \
1415                         "MDSDEV2=<nonexistent_file> "                   \
1416                         "(or MDSDEV, in the case of b1_8) "             \
1417                         "OSTCOUNT=2 OSTDEV1=<nonexistent_file> "        \
1418                         "OSTDEV2=<nonexistent_file>"
1419         fi
1420
1421         mkdir $tmp || {
1422                 echo "Found stale $tmp"
1423                 return 1
1424         }
1425
1426         mkdir $tmp/src || return 1
1427         tar cf - -C $src . | tar xf - -C $tmp/src
1428
1429         # format ost with comma-separated NIDs to verify LU-4460
1430         local failnid="$(h2nettype 1.2.3.4),$(h2nettype 4.3.2.1)"
1431         MGSNID="$MGSNID,$MGSNID" OSTOPT="--failnode=$failnid" formatall
1432
1433         setupall
1434
1435         [[ "$MDS1_VERSION" -ge $(version_code 2.3.50) ]] ||
1436                 $LFS quotacheck -ug /mnt/$FSNAME
1437         $LFS setquota -u $T32_QID -b 0 -B $T32_BLIMIT -i 0 -I $T32_ILIMIT \
1438                 /mnt/$FSNAME
1439
1440         if [[ $MDSCOUNT -ge 2 ]]; then
1441                 remote_dir=/mnt/$FSNAME/remote_dir
1442                 $LFS mkdir -i 1 $remote_dir
1443                 tar cf - -C $tmp/src . | tar xf - -C $remote_dir
1444
1445                 target_dir=$remote_dir
1446                 if [[ $MDS1_VERSION -ge $(version_code 2.7.0) ]]; then
1447                         striped_dir=/mnt/$FSNAME/striped_dir_old
1448                         $LFS mkdir -i 1 -c 2 $striped_dir
1449                         tar cf - -C $tmp/src . | tar xf - -C $striped_dir
1450                 fi
1451         else
1452                 tar cf - -C $tmp/src . | tar xf - -C /mnt/$FSNAME
1453                 target_dir=/mnt/$FSNAME
1454         fi
1455
1456         # add project quota #
1457         [[ $mds1_FSTYPE == "ldiskfs" &&
1458                 $MDS1_VERSION -gt $(version_code 2.9.55) ]] ||
1459         [[ $mds1_FSTYPE == "zfs" &&
1460                 $MDS1_VERSION -gt $(version_code 2.10.53) ]] && {
1461                 pj_quota_dir=$target_dir/project_quota_dir
1462                 pj_quota_file_old=$pj_quota_dir/pj_quota_file_old
1463
1464                 enable_project_quota
1465                 set_mdt_qtype ugp ||
1466                         error "enable mdt quota failed"
1467
1468                 set_ost_qtype ugp ||
1469                         error "enable ost quota failed"
1470
1471                 mkdir -p $pj_quota_dir
1472                 $LFS setquota -p $T32_PRJID -b 0 -B $T32_PROLIMIT -i 0 \
1473                         -I $T32_ILIMIT $pj_quota_dir ||
1474                         error "setquota -p $T32_PRJID failed"
1475
1476                 $LFS setstripe $pj_quota_file_old -c 1 ||
1477                         error "setstripe $pj_quota_file_old failed"
1478
1479                 chown $T32_QID:$T32_QID $pj_quota_file_old ||
1480                         error "chown $pj_quota_file_old failed"
1481
1482                 change_project -p $T32_PRJID $pj_quota_file_old
1483
1484                 mkdir -p $tmp/src/project_quota_dir
1485                 cp $pj_quota_file_old $tmp/src/project_quota_dir/
1486         }
1487
1488         #####################
1489         tar cf - -C $tmp/src . | tar xf - -C /mnt/$FSNAME
1490
1491         #if [[ $MDSCOUNT -ge 2 ]]; then
1492         #       remote_dir=/mnt/$FSNAME/remote_dir
1493         #       $LFS mkdir -i 1 $remote_dir
1494         #       tar cf - -C $tmp/src . | tar xf - -C $remote_dir
1495
1496         #       if [[ "$MDS1_VERSION" -ge $(version_code 2.7.0) ]]; then
1497         #               striped_dir=/mnt/$FSNAME/striped_dir_old
1498         #               $LFS mkdir -i 1 -c 2 $striped_dir
1499         #               tar cf - -C $tmp/src . | tar xf - -C $striped_dir
1500         #       fi
1501         #fi
1502
1503         # PFL file #
1504         if [[ $MDS1_VERSION -ge $(version_code 2.9.51) ]]; then
1505                 pfl_dir=$target_dir/pfl_dir
1506                 pfl_file=$pfl_dir/pfl_file
1507                 mkdir -p $pfl_dir
1508                 $LFS setstripe -E 2M -c 1 -o 0 -E -1 -S 2M -c 1 -o 1 \
1509                                         $pfl_file ||
1510                         error "Create PFL file failed"
1511
1512                 dd if=/dev/urandom of=$pfl_file bs=1k count=3k
1513                 mkdir -p $tmp/src/pfl_dir
1514                 cp $pfl_file $tmp/src/pfl_dir/
1515         fi
1516
1517         ############
1518         # DoM / FLR file #
1519         if [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]]; then
1520                 dom_dir=$target_dir/dom_dir
1521                 dom_file=$dom_dir/dom_file
1522                 flr_dir=$target_dir/flr_dir
1523                 flr_file=$flr_dir/flr_file
1524
1525                 mkdir -p $dom_dir
1526                 $LFS setstripe -E 1M -L mdt -E -1 -S 4M $dom_file
1527                 dd if=/dev/urandom of=$dom_file bs=1k count=2k
1528                 mkdir -p $tmp/src/dom_dir
1529                 cp $dom_file $tmp/src/dom_dir
1530         # FLR #
1531                 mkdir -p $flr_dir
1532                 $LFS mirror create -N2 $flr_file
1533                 dd if=/dev/urandom of=$flr_file bs=1k count=1
1534                 mkdir -p $tmp/src/flr_dir
1535                 cp $flr_file $tmp/src/flr_dir
1536         fi
1537         ############
1538
1539         local large_xattr_dir=/mnt/$FSNAME/large_xattr_test_dir
1540         local xattr_file=$large_xattr_dir/large_xattr_file
1541
1542         mkdir $large_xattr_dir
1543         touch $xattr_file
1544         setfattr -n user.fooattr -v $(printf "%c" {1..4096} ) $xattr_file ||
1545                 rm -f $xattr_file
1546
1547         stopall
1548
1549         mkdir $tmp/img || return 1
1550
1551         setupall
1552
1553         pushd_dir=/mnt/$FSNAME
1554         if [[ $MDSCOUNT -ge 2 ]]; then
1555                 pushd_dir=$remote_dir
1556                 if [[ "$MDS1_VERSION" -ge $(version_code 2.7.0) ]]; then
1557                         pushd $striped_dir
1558                         BLOCKSIZE=1024 ls -Rni --time-style=+%s >$tmp/img/list2
1559                         popd
1560                 fi
1561         fi
1562
1563         pushd $pushd_dir
1564         BLOCKSIZE=1024 ls -Rni --time-style=+%s >$tmp/img/list
1565         find ! -name .lustre -type f -exec sha1sum {} \; |
1566                 sort -k 2 >$tmp/img/sha1sums
1567         popd
1568         $LCTL get_param -n version | head -n 1 |
1569                 sed -e 's/^lustre: *//' >$tmp/img/commit
1570
1571         [[ "$MDS1_VERSION" -ge $(version_code 2.3.50) ]] ||
1572                 $LFS quotaon -ug /mnt/$FSNAME
1573         $LFS quota -u $T32_QID -v /mnt/$FSNAME
1574         $LFS quota -v -u $T32_QID /mnt/$FSNAME |
1575                 awk 'BEGIN { num='1' } { if ($1 == "'/mnt/$FSNAME'") \
1576                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1577                 | tr -d "*" > $tmp/img/bspace
1578         $LFS quota -v -u $T32_QID /mnt/$FSNAME |
1579                 awk 'BEGIN { num='5' } { if ($1 == "'/mnt/$FSNAME'") \
1580                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1581                 | tr -d "*" > $tmp/img/ispace
1582         echo $T32_BLIMIT > $tmp/img/blimit
1583         echo $T32_ILIMIT > $tmp/img/ilimit
1584
1585         $MULTIOP /mnt/$FSNAME/orph_file Ouw_c&
1586         pid=$!
1587         sync
1588         stop_mdt_no_force 1
1589         debugfs -R "ls /PENDING" ${MDSDEV1:-$MDSDEV}
1590         cp ${MDSDEV1:-$MDSDEV} $tmp/img
1591         start_mdt 1
1592         kill -s USR1 $pid
1593         wait $pid
1594
1595         #################
1596         stopall
1597
1598         pushd $tmp/src
1599         find -type f -exec sha1sum {} \; | sort -k 2 >$tmp/sha1sums.src
1600         popd
1601
1602         if ! diff -u $tmp/sha1sums.src $tmp/img/sha1sums; then
1603                 echo "Data verification failed"
1604         fi
1605
1606         uname -r >$tmp/img/kernel
1607         uname -m >$tmp/img/arch
1608
1609         for ((num=1; num <= $MDSCOUNT; num++)); do
1610                 local devname=$(mdsdevname $num)
1611                 local facet=mds$num
1612                 local image_name
1613
1614                 [[ num -eq 1 ]] && image_name=mdt || image_name=mdt$num
1615                 [[ $(facet_fstype $facet) != zfs ]] ||
1616                         devname=$(mdsvdevname $num)
1617                 dd conv=sparse bs=4k if=$devname of=$tmp/img/$image_name
1618         done
1619
1620         for ((num=1; num <= $OSTCOUNT; num++)); do
1621                 local devname=$(ostdevname $num)
1622                 local facet=oss$num
1623                 local image_name
1624
1625                 [[ num -eq 1 ]] && image_name=ost || image_name=ost$num
1626                 [[ $(facet_fstype $facet) != zfs ]] ||
1627                         devname=$(ostdevname $num)
1628                 dd conv=sparse bs=4k if=$devname of=$tmp/img/$image_name
1629         done
1630
1631         version=$(sed -e 's/\(^[0-9]\+\.[0-9]\+\)\(.*$\)/\1/' $tmp/img/commit |
1632                           sed -e 's/\./_/g')    # E.g., "1.8.7" -> "1_8"
1633         dst=$(cd $dst; pwd)
1634         pushd $tmp/img
1635         tar cjvf $dst/disk$version-"$mds1_FSTYPE".tar.bz2 -S *
1636         popd
1637
1638         rm -r $tmp
1639 }
1640 # run_test 32newtarball "Create a new test_32 disk image tarball for this version"
1641
1642 #
1643 # The list of applicable tarballs is returned via the caller's
1644 # variable "tarballs".
1645 #
1646 t32_check() {
1647         [ "$CLIENTONLY" ] && skip "Client-only testing"
1648
1649         check_versions || skip "do not upgrade with mismatched client/server"
1650
1651         local node=$(facet_active_host $SINGLEMDS)
1652         local r="do_node $node"
1653
1654         ! $r which "$TUNEFS" && skip_env "tunefs.lustre required on $node"
1655
1656         local IMGTYPE="$mds1_FSTYPE"
1657
1658         [[ -n "$T32IMAGE" ]] && tarballs=$T32IMAGE ||
1659                 tarballs=$($r find $RLUSTRE/tests -maxdepth 1 \
1660                            -name \'disk*-$IMGTYPE.tar.bz2\')
1661
1662         [ -z "$tarballs" ] && skip "No applicable tarballs found"
1663 }
1664
1665 t32_test_cleanup() {
1666         local tmp=$TMP/t32
1667         local facet=$SINGLEMDS
1668         local rc=$?
1669
1670         echo "== cleanup with rc=$rc =="
1671         if $shall_cleanup_lustre; then
1672                 umount $tmp/mnt/lustre || rc=$?
1673         fi
1674         if $shall_cleanup_mdt; then
1675                 $r $UMOUNT $tmp/mnt/mdt || rc=$?
1676         fi
1677         if $shall_cleanup_mdt1; then
1678                 $r $UMOUNT $tmp/mnt/mdt1 || rc=$?
1679         fi
1680         if $shall_cleanup_ost; then
1681                 $r $UMOUNT $tmp/mnt/ost || rc=$?
1682         fi
1683         if $shall_cleanup_ost1; then
1684                 $r $UMOUNT $tmp/mnt/ost1 || rc=$?
1685         fi
1686
1687         $r rm -rf $tmp
1688         rm -rf $tmp
1689         if [[ "$mds1_FSTYPE" == zfs ]]; then
1690                 local poolname
1691                 local poolname_list="t32fs-mdt1 t32fs-ost1"
1692
1693                 ! $mdt2_is_available || poolname_list+=" t32fs-mdt2"
1694
1695                 for poolname in $poolname_list; do
1696                         destroy_zpool $facet $poolname
1697                 done
1698         fi
1699         combined_mgs_mds || start_mgs || rc=$?
1700         return $rc
1701 }
1702
1703 t32_bits_per_long() {
1704         #
1705         # Yes, this is not meant to be perfect.
1706         #
1707         case $1 in
1708                 ppc64|x86_64)
1709                         echo -n 64;;
1710                 i*86)
1711                         echo -n 32;;
1712         esac
1713 }
1714
1715 t32_reload_modules() {
1716         local node=$1
1717         local all_removed=false
1718         local i=0
1719
1720         [ "$mds1_FSTYPE" == zfs ] && do_rpc_nodes $node "service zed stop"
1721
1722         while ((i < 20)); do
1723                 echo "Unloading modules on $node: Attempt $i"
1724                 do_rpc_nodes $node $LUSTRE_RMMOD "$mds1_FSTYPE" &&
1725                         all_removed=true
1726                 do_rpc_nodes $node check_mem_leak || return 1
1727                 if $all_removed; then
1728                         do_rpc_nodes $node load_modules
1729                         return 0
1730                 fi
1731                 if [ "$mds1_FSTYPE" == zfs ]; then
1732                         do_rpc_nodes $node "$ZPOOL status -v"
1733                 fi
1734                 sleep 5
1735                 i=$((i + 1))
1736         done
1737         echo "Unloading modules on $node: Given up"
1738         return 1
1739 }
1740
1741 t32_wait_til_devices_gone() {
1742         local node=$1
1743         local devices
1744         local loops
1745         local i=0
1746
1747         echo wait for devices to go
1748         while ((i < 20)); do
1749                 devices=$(do_rpc_nodes $node $LCTL device_list | wc -l)
1750                 loops=$(do_rpc_nodes $node losetup -a | grep -c t32)
1751                 ((devices == 0 && loops == 0)) && return 0
1752                 sleep 5
1753                 i=$((i + 1))
1754         done
1755         echo "waiting for dev on $node: dev $devices loop $loops given up"
1756         do_rpc_nodes $node "losetup -a"
1757         do_rpc_nodes $node "$LCTL device_list"
1758         return 1
1759 }
1760
1761 t32_verify_quota() {
1762         local facet=$1
1763         local fsname=$2
1764         local mnt=$3
1765         local qval
1766         local cmd
1767
1768         # LU-2435: if the underlying zfs doesn't support userobj_accounting,
1769         # lustre will estimate the object count usage. This fails quota
1770         # verification in 32b. The object quota usage should be accurate after
1771         # zfs-0.7.0 is released.
1772         [ "$mds1_FSTYPE" == zfs ] && {
1773                 local zfs_version=$(do_facet $facet cat /sys/module/zfs/version)
1774
1775                 [ $(version_code $zfs_version) -lt $(version_code 0.7.0) ] && {
1776                         echo "Skip quota verify for zfs: $zfs_version"
1777                         return 0
1778                 }
1779         }
1780
1781         $LFS quota -u $T32_QID -v $mnt
1782
1783         qval=$($LFS quota -v -u $T32_QID $mnt |
1784                 awk 'BEGIN { num='1' } { if ($1 == "'$mnt'") \
1785                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1786                 | tr -d "*")
1787         [ $qval -eq $img_bspace ] || {
1788                 echo "bspace, act:$qval, exp:$img_bspace"
1789                 return 1
1790         }
1791
1792         qval=$($LFS quota -v -u $T32_QID $mnt |
1793                 awk 'BEGIN { num='5' } { if ($1 == "'$mnt'") \
1794                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1795                 | tr -d "*")
1796         [ $qval -eq $img_ispace ] || {
1797                 echo "ispace, act:$qval, exp:$img_ispace"
1798                 return 1
1799         }
1800
1801         qval=$($LFS quota -v -u $T32_QID $mnt |
1802                 awk 'BEGIN { num='3' } { if ($1 == "'$mnt'") \
1803                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1804                 | tr -d "*")
1805         [ $qval -eq $img_blimit ] || {
1806                 echo "blimit, act:$qval, exp:$img_blimit"
1807                 return 1
1808         }
1809
1810         qval=$($LFS quota -v -u $T32_QID $mnt |
1811                 awk 'BEGIN { num='7' } { if ($1 == "'$mnt'") \
1812                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1813                 | tr -d "*")
1814         [ $qval -eq $img_ilimit ] || {
1815                 echo "ilimit, act:$qval, exp:$img_ilimit"
1816                 return 1
1817         }
1818
1819         set_persistent_param_and_check $facet \
1820                 "osd-$mds1_FSTYPE.$fsname-MDT0000.quota_slave.enabled" \
1821                 "$fsname.quota.mdt" ug
1822
1823         set_persistent_param_and_check $facet \
1824                 "osd-$mds1_FSTYPE.$fsname-OST0000.quota_slave.enabled" \
1825                 "$fsname.quota.ost" ug
1826
1827         chmod 0777 $mnt
1828         runas -u $T32_QID -g $T32_QID dd if=/dev/zero of=$mnt/t32_qf_new \
1829                 bs=1M count=$((img_blimit / 1024)) oflag=sync && {
1830                 echo "Write succeed, but expect -EDQUOT"
1831                 return 1
1832         }
1833         rm -f $mnt/t32_qf_new
1834
1835         runas -u $T32_QID -g $T32_QID createmany -m $mnt/t32_qf_ \
1836                 $img_ilimit && {
1837                 echo "Create succeed, but expect -EDQUOT"
1838                 return 1
1839         }
1840         unlinkmany $mnt/t32_qf_ $img_ilimit
1841
1842         return 0
1843 }
1844
1845 getquota() {
1846         local spec=$4
1847         local uuid=$3
1848         local mnt=$5
1849
1850         sync_all_data > /dev/null 2>&1 || true
1851
1852         [ "$uuid" != "global" ] || uuid=$mnt
1853
1854         $LFS quota -v "$1" "$2" $mnt |
1855                 awk 'BEGIN { num='$spec' } { if ($1 == "'$uuid'") \
1856                 { if (NF == 1) { getline } else { num++ } ; print $num;} }' \
1857                 | tr -d "*"
1858 }
1859
1860 t32_test() {
1861         local tarball=$1
1862         local writeconf=$2
1863         local dne_upgrade=${dne_upgrade:-"no"}
1864         local dom_upgrade=${dom_upgrade:-"no"}
1865         local project_upgrade=${project_upgrade:-"no"}
1866         local ff_convert=${ff_convert:-"no"}
1867         local pfl_upgrade=${pfl_upgrade:-"no"}
1868         local project_quota_upgrade=${project_quota_upgrade:-"no"}
1869         local dom_new_upgrade=${dom_new_upgrade:-"no"}
1870         local flr_upgrade=${flr_upgrade:-"no"}
1871         local shall_cleanup_mdt=false
1872         local shall_cleanup_mdt1=false
1873         local shall_cleanup_ost=false
1874         local shall_cleanup_ost1=false
1875         local shall_cleanup_lustre=false
1876         local mdt2_is_available=false
1877         local ost2_is_available=false
1878         local node=$(facet_active_host $SINGLEMDS)
1879         local r="do_node $node"
1880         local tmp=$TMP/t32
1881         local img_commit
1882         local img_kernel
1883         local img_arch
1884         local img_bspace
1885         local img_ispace
1886         local img_blimit
1887         local img_ilimit
1888         local fsname=t32fs
1889         local nid
1890         local mopts
1891         local uuid
1892         local nrpcs_orig
1893         local nrpcs
1894         local list
1895         local mdt_dev=$tmp/mdt
1896         local mdt2_dev=$tmp/mdt2
1897         local ost_dev=$tmp/ost
1898         local ost2_dev=$tmp/ost2
1899         local stripe_index
1900         local stripe_count
1901         local dir
1902         local pfl_file=$tmp/mnt/lustre/remote_dir/pfl_dir/pfl_file
1903         local flr_file=$tmp/mnt/lustre/remote_dir/flr_dir/flr_file
1904         local dom_file=$tmp/mnt/lustre/remote_dir/dom_dir/dom_file
1905         local quota_dir=$tmp/mnt/lustre/remote_dir/project_quota_dir
1906
1907         combined_mgs_mds || stop_mgs || error "Unable to stop MGS"
1908         trap 'trap - RETURN; t32_test_cleanup' RETURN
1909
1910         load_modules
1911         nid=$($r $LCTL list_nids | head -1)
1912
1913         mkdir -p $tmp/mnt/lustre || error "mkdir $tmp/mnt/lustre failed"
1914         $r mkdir -p $tmp/mnt/{mdt,mdt1,ost,ost1}
1915         $r tar xjvf $tarball -S -C $tmp || {
1916                 error_noexit "Unpacking the disk image tarball"
1917                 return 1
1918         }
1919         img_commit=$($r cat $tmp/commit)
1920         img_kernel=$($r cat $tmp/kernel)
1921         img_arch=$($r cat $tmp/arch)
1922         img_bspace=$($r cat $tmp/bspace)
1923         img_ispace=$($r cat $tmp/ispace)
1924
1925         # older images did not have "blimit" and "ilimit" files
1926         # use old values for T32_BLIMIT and T32_ILIMIT
1927         $r test -f $tmp/blimit && img_blimit=$($r cat $tmp/blimit) ||
1928                 img_blimit=20480
1929         $r test -f $tmp/ilimit && img_ilimit=$($r cat $tmp/ilimit) ||
1930                 img_ilimit=2
1931
1932         echo "Upgrading from $(basename $tarball), created with:"
1933         echo "  Commit: $img_commit"
1934         echo "  Kernel: $img_kernel"
1935         echo "    Arch: $img_arch"
1936         echo "OST version: $(lustre_build_version ost1)"
1937
1938         # The conversion can be made only when both of the following
1939         # conditions are satisfied:
1940         # - ost device img version < 2.3.64
1941         # - ost server version >= 2.5
1942         [ $(version_code $img_commit) -ge $(version_code 2.3.64) -o \
1943                 "$OST1_VERSION" -lt $(version_code 2.5.0) ] &&
1944                         ff_convert="no"
1945
1946         ! $r test -f $mdt2_dev || mdt2_is_available=true
1947         ! $r test -f $ost2_dev || ost2_is_available=true
1948
1949         if [[ "$mds1_FSTYPE" == zfs ]]; then
1950                 echo "== fstype is zfs =="
1951                 # import pool first
1952                 local poolname
1953                 local poolname_list="t32fs-mdt1 t32fs-ost1"
1954
1955                 ! $mdt2_is_available || poolname_list+=" t32fs-mdt2"
1956
1957                 for poolname in $poolname_list; do
1958                         $r "modprobe zfs;
1959                                 $ZPOOL list -H $poolname >/dev/null 2>&1 ||
1960                                 $ZPOOL import -f -d $tmp $poolname"
1961                 done
1962
1963                 # upgrade zpool to latest supported features, including
1964                 # dnode quota accounting in 0.7.0
1965                 $r "$ZPOOL upgrade -a"
1966
1967                 mdt_dev=t32fs-mdt1/mdt1
1968                 ost_dev=t32fs-ost1/ost1
1969                 ! $mdt2_is_available || mdt2_dev=t32fs-mdt2/mdt2
1970                 ! $ost2_is_available || ost2_dev=t32fs-ost2/ost2
1971                 wait_update_facet $SINGLEMDS "$ZPOOL list |
1972                         awk '/^t32fs-mdt1/ { print \\\$1 }'" "t32fs-mdt1" || {
1973                                 error_noexit "import zfs pool failed"
1974                                 return 1
1975                         }
1976         elif [ "$project_upgrade" != "no" ]; then
1977                 echo "== project upgrade =="
1978                 ! $r tune2fs -O project $mdt_dev &&
1979                         error_noexit "enable project on mdt0 failed" &&
1980                                 return 1
1981                 $mdt2_is_available && ! $r tune2fs "-O project" $mdt2_dev &&
1982                         error_noexit "enable project on mdt failed" &&
1983                                 return 1
1984                 ! $r tune2fs -O project $ost_dev &&
1985                         error_noexit "enable project on ost failed" &&
1986                                 return 1
1987                 $ost2_is_available && ! $r tune2fs -O project $ost2_dev &&
1988                         error_noexit "enable project on ost2 failed" &&
1989                                 return 1
1990         fi
1991
1992         $r $LCTL set_param debug="$PTLDEBUG"
1993
1994         $r $TUNEFS --dryrun $mdt_dev || {
1995                 $r losetup -a
1996                 error_noexit "tunefs.lustre before mounting the MDT"
1997                 return 1
1998         }
1999
2000         if $mdt2_is_available; then
2001                 $r $TUNEFS --dryrun $mdt2_dev || {
2002                         $r losetup -a
2003                         error_noexit "tunefs.lustre before mounting the MDT"
2004                         return 1
2005                 }
2006         fi
2007
2008         if [ "$writeconf" ]; then
2009                 echo "== writeconf mdt tunefs and quota =="
2010                 mopts=writeconf
2011                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2012                         mopts="loop,$mopts"
2013                         $r $TUNEFS --quota $mdt_dev || {
2014                                 $r losetup -a
2015                                 error_noexit "Enable mdt quota feature"
2016                                 return 1
2017                         }
2018
2019                         if [ "$project_quota_upgrade" != "no" ]; then
2020                                 echo "== enable mdt2 project quota =="
2021                                 $r $TUNE2FS -O project $mdt_dev || {
2022                                         $r losetup -a
2023                                         error_noexit "tune2fs $mdt_dev failed"
2024                                         return 1
2025                                 }
2026                         fi
2027
2028                         if $mdt2_is_available; then
2029                                 $r $TUNEFS --quota $mdt2_dev || {
2030                                         $r losetup -a
2031                                         error_noexit "Enable mdt2 quota feature"
2032                                         return 1
2033                                 }
2034                                 if [ "$project_quota_upgrade" != "no" ]; then
2035                                         echo "== enable mdt2 project quota =="
2036                                         $r $TUNE2FS -O project $mdt2_dev || {
2037                                                 $r losetup -a
2038                                                 error_noexit \
2039                                                     "tune2fs $mdt2_dev failed"
2040                                                 return 1
2041                                         }
2042                                 fi
2043                         fi
2044                 fi
2045         else
2046                 echo "== replace nids =="
2047                 if [ -n "$($LCTL list_nids | grep -v '\(tcp\|lo\)[[:digit:]]*$')" ]; then
2048                         [[ "$MGS_VERSION" -ge $(version_code 2.3.59) ]] ||
2049                         skip "LU-2200: Cannot run over IB w/o lctl replace_nids "
2050                                 "(Need MGS version at least 2.3.59)"
2051                 fi
2052
2053                 local osthost=$(facet_active_host ost1)
2054                 local ostnid=$(do_node $osthost $LCTL list_nids | head -1)
2055
2056                 mopts=nosvc
2057                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2058                         mopts="loop,$mopts"
2059                 fi
2060                 $r $MOUNT_CMD -o $mopts $mdt_dev $tmp/mnt/mdt
2061                 $r $LCTL replace_nids $fsname-OST0000 $ostnid || {
2062                         $r $LCTL dl
2063                         error_noexit "replace_nids $fsname-OST0000 $ostnid failed"
2064                         return 1
2065                 }
2066                 if $ost2_is_available; then
2067                         $r $LCTL replace_nids $fsname-OST0001 $ostnid || {
2068                                 $r $LCTL dl
2069                                 error_noexit "replace_nids $fsname-OST0001 $ostnid failed"
2070                                 return 1
2071                         }
2072                 fi
2073                 $r $LCTL replace_nids $fsname-MDT0000 $nid || {
2074                         $r $LCTL dl
2075                         error_noexit "replace_nids $fsname-MDT0000 $nid failed"
2076                         return 1
2077                 }
2078                 if $mdt2_is_available; then
2079                         $r $LCTL replace_nids $fsname-MDT0001 $nid || {
2080                                 $r $LCTL dl
2081                                 error_noexit "replace_nids $fsname-MDT0001 $nid failed"
2082                                 return 1
2083                         }
2084                 fi
2085                 $r $UMOUNT $tmp/mnt/mdt
2086
2087                 mopts=exclude=$fsname-OST0000
2088                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2089                         mopts="loop,$mopts"
2090                 fi
2091         fi
2092
2093         t32_wait_til_devices_gone $node
2094
2095         $r $MOUNT_CMD -o $mopts $mdt_dev $tmp/mnt/mdt || {
2096                 $r losetup -a
2097                 error_noexit "Mounting the MDT"
2098                 return 1
2099         }
2100         shall_cleanup_mdt=true
2101
2102         if $mdt2_is_available; then
2103                 echo "== mdt2 available =="
2104                 mopts=mgsnode=$nid,$mopts
2105                 $r $MOUNT_CMD -o $mopts $mdt2_dev $tmp/mnt/mdt1 || {
2106                         $r losetup -a
2107                         error_noexit "Mounting the MDT"
2108                         return 1
2109                 }
2110                 shall_cleanup_mdt1=true
2111                 echo "== mount new MDT $mdt2_dev =="
2112
2113                 $r $LCTL set_param -n mdt.${fsname}*.enable_remote_dir=1 || {
2114                         error_noexit "enable remote dir create failed"
2115                         return 1
2116                 }
2117
2118         elif [ "$dne_upgrade" != "no" ]; then
2119                 local fs2mdsdev=$(mdsdevname 1_2)
2120                 local fs2mdsvdev=$(mdsvdevname 1_2)
2121
2122                 echo "== mkfs new MDT on ${fs2mdsdev} =="
2123                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2124                         mkfsoptions="--mkfsoptions=\\\"-J size=8\\\""
2125                 fi
2126
2127                 add $SINGLEMDS $(mds2failover_HOST="" \
2128                         mkfs_opts mds2 $fs2mdsdev $fsname) --reformat \
2129                         $mkfsoptions $fs2mdsdev $fs2mdsvdev > /dev/null || {
2130                         error_noexit "Mkfs new MDT failed"
2131                         return 1
2132                 }
2133
2134                 [[ "$mds1_FSTYPE" != zfs ]] || import_zpool mds1
2135
2136                 $r $TUNEFS --dryrun $fs2mdsdev || {
2137                         error_noexit "tunefs.lustre before mounting the MDT"
2138                         return 1
2139                 }
2140
2141                 echo "== mount new MDT....$fs2mdsdev =="
2142                 $r $MOUNT_CMD -o $mopts $fs2mdsdev $tmp/mnt/mdt1 || {
2143                         error_noexit "mount mdt1 failed"
2144                         return 1
2145                 }
2146
2147                 $r $LCTL set_param -n mdt.${fsname}*.enable_remote_dir=1 ||
2148                         error_noexit "enable remote dir create failed"
2149
2150                 shall_cleanup_mdt1=true
2151         fi
2152
2153         uuid=$($r $LCTL get_param -n mdt.$fsname-MDT0000.uuid) || {
2154                 error_noexit "Getting MDT UUID"
2155                 return 1
2156         }
2157         if [ "$uuid" != $fsname-MDT0000_UUID ]; then
2158                 error_noexit "Unexpected MDT UUID: \"$uuid\""
2159                 return 1
2160         fi
2161
2162         $r $TUNEFS --dryrun $ost_dev || {
2163                 error_noexit "tunefs.lustre before mounting the OST"
2164                 return 1
2165         }
2166
2167         if $ost2_is_available; then
2168                 $r $TUNEFS --dryrun $ost2_dev || {
2169                         error_noexit "tunefs.lustre before mounting the OST"
2170                         return 1
2171                 }
2172         fi
2173
2174         if [ "$writeconf" ]; then
2175                 echo "== writeconf and ost quota tunefs =="
2176                 mopts=mgsnode=$nid,$writeconf
2177                 if [ "$ost1_FSTYPE" == ldiskfs ]; then
2178                         mopts="loop,$mopts"
2179                         $r $TUNEFS --quota $ost_dev || {
2180                                 $r losetup -a
2181                                 error_noexit "Enable ost quota feature"
2182                                 return 1
2183                         }
2184
2185                         if [ "$project_quota_upgrade" != "no" ]; then
2186                                 echo "== enable ost project quota =="
2187                                 $r $TUNE2FS -O project $ost_dev || {
2188                                         $r losetup -a
2189                                         error_noexit "tune2fs $ost_dev failed"
2190                                         return 1
2191                                 }
2192                         fi
2193
2194                         if $ost2_is_available; then
2195                                 $r $TUNEFS --quota $ost2_dev || {
2196                                         $r losetup -a
2197                                         error_noexit "Enable ost2 quota feature"
2198                                         return 1
2199                                 }
2200                                 if [ "$project_quota_upgrade" != "no" ]; then
2201                                         echo "== enable ost2 project quota =="
2202                                         $r $TUNE2FS -O project $ost2_dev || {
2203                                                 $r losetup -a
2204                                                 error_noexit \
2205                                                 "tune2fs $ost2_dev failed"
2206                                                 return 1
2207                                         }
2208                                 fi
2209                         fi
2210                 fi
2211         else
2212                 mopts=mgsnode=$nid
2213                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2214                         mopts="loop,$mopts"
2215                 fi
2216         fi
2217
2218         $r $MOUNT_CMD -onomgs -o$mopts $ost_dev $tmp/mnt/ost || {
2219                 error_noexit "Mounting the OST"
2220                 return 1
2221         }
2222
2223         if $ost2_is_available; then
2224                 $r $MOUNT_CMD -onomgs -o$mopts $ost2_dev $tmp/mnt/ost1 || {
2225                         error_noexit "Mounting the OST2"
2226                         return 1
2227                 }
2228                 shall_cleanup_ost1=true
2229         fi
2230
2231         shall_cleanup_ost=true
2232
2233         uuid=$($r $LCTL get_param -n obdfilter.$fsname-OST0000.uuid) || {
2234                 error_noexit "Getting OST UUID"
2235                 return 1
2236         }
2237         if [ "$uuid" != $fsname-OST0000_UUID ]; then
2238                 error_noexit "Unexpected OST UUID: \"$uuid\""
2239                 return 1
2240         fi
2241
2242         if $ost2_is_available; then
2243                 uuid=$($r $LCTL get_param -n obdfilter.$fsname-OST0001.uuid) ||{
2244                         error_noexit "Getting OST1 UUID"
2245                         return 1
2246                 }
2247                 if [ "$uuid" != $fsname-OST0001_UUID ]; then
2248                         error_noexit "Unexpected OST1 UUID: \"$uuid\""
2249                         return 1
2250                 fi
2251         fi
2252
2253         if [[ $PERM_CMD =~ "set_param" ]]; then
2254                 echo "== perm cmd = '$PERM_CMD' =="
2255                 $r $PERM_CMD osc.$fsname-OST0000*.import=connection=$nid || {
2256                         error_noexit "Setting OST \"failover.node\""
2257                         return 1
2258                 }
2259                 $r $PERM_CMD mdc.$fsname-MDT0000*.import=connection=$nid || {
2260                         error_noexit "Setting MDT \"failover.node\""
2261                         return 1
2262                 }
2263                 $r $PERM_CMD osc.$fsname-OST0000-*.max_dirty_mb=15 || {
2264                         error_noexit "Setting \"max_dirty_mb\""
2265                         return 1
2266                 }
2267                 $r $PERM_CMD mdc.$fsname-MDT0000-*.max_rpcs_in_flight=9 || {
2268                         error_noexit "Setting \"max_rpcs_in_flight\""
2269                         return 1
2270                 }
2271                 $r $PERM_CMD lov.$fsname-MDT0000-*.stripesize=4M || {
2272                         error_noexit "Setting \"lov.stripesize\""
2273                         return 1
2274                 }
2275                 $r $PERM_CMD mdd.$fsname-MDT0000-*.atime_diff=70 || {
2276                         error_noexit "Setting \"mdd.atime_diff\""
2277                         return 1
2278                 }
2279         else
2280                 echo "== perm cmd = '$PERM_CMD' =="
2281                 $r $PERM_CMD $fsname-OST0000.failover.node=$nid || {
2282                         error_noexit "Setting OST \"failover.node\""
2283                         return 1
2284                 }
2285
2286                 $r $PERM_CMD $fsname-MDT0000.failover.node=$nid || {
2287                         error_noexit "Setting MDT \"failover.node\""
2288                         return 1
2289                 }
2290
2291                 $r $PERM_CMD $fsname-OST0000.osc.max_dirty_mb=15 || {
2292                         error_noexit "Setting \"max_dirty_mb\""
2293                         return 1
2294                 }
2295                 $r $PERM_CMD $fsname-MDT0000.mdc.max_rpcs_in_flight=9 || {
2296                         error_noexit "Setting \"max_rpcs_in_flight\""
2297                         return 1
2298                 }
2299                 $r $PERM_CMD $fsname-MDT0000.lov.stripesize=4M || {
2300                         error_noexit "Setting \"lov.stripesize\""
2301                         return 1
2302                 }
2303                 $r $PERM_CMD $fsname-MDT0000.mdd.atime_diff=70 || {
2304                         error_noexit "Setting \"mdd.atime_diff\""
2305                         return 1
2306                 }
2307         fi
2308
2309         $r $LCTL pool_new $fsname.interop || {
2310                 error_noexit "Setting \"interop\""
2311                 return 1
2312         }
2313
2314         if [ "$ff_convert" != "no" -a "$ost1_FSTYPE" == ldiskfs ]; then
2315                 echo "== ff convert ($ff_convert) =="
2316                 $r $LCTL lfsck_start -M $fsname-OST0000 || {
2317                         error_noexit "Start OI scrub on OST0"
2318                         return 1
2319                 }
2320
2321                 # The oi_scrub should be on ost1, but for test_32(),
2322                 # all on the SINGLEMDS.
2323                 wait_update_facet $SINGLEMDS "$LCTL get_param -n \
2324                         osd-ldiskfs.$fsname-OST0000.oi_scrub |
2325                         awk '/^status/ { print \\\$2 }'" "completed" 30 || {
2326                         error_noexit "Failed to get the expected 'completed'"
2327                         return 1
2328                 }
2329
2330                 local UPDATED=$($r $LCTL get_param -n \
2331                                 osd-ldiskfs.$fsname-OST0000.oi_scrub |
2332                                 awk '/^updated/ { print $2 }')
2333                 [ $UPDATED -ge 1 ] || {
2334                         error_noexit "Only $UPDATED objects have been converted"
2335                         return 1
2336                 }
2337         fi
2338
2339         if [[ "$dne_upgrade" != "no" ]] || $mdt2_is_available; then
2340                 echo "== dne upgrate ($dne_upgrade) or mdt2 available =="
2341                 if [[ $PERM_CMD =~ "set_param" ]]; then
2342                         $r $PERM_CMD mdc.$fsname-MDT0001*.import=connection=$nid || {
2343                                 error_noexit "Setting MDT1 \"failover.node\""
2344                                 return 1
2345                         }
2346
2347                         $r $PERM_CMD mdc.$fsname-MDT0001-*.max_rpcs_in_flight=9 || {
2348                                 error_noexit "Setting MDT1 \"max_rpcs_in_flight\""
2349                                 return 1
2350                         }
2351                         $r $PERM_CMD lov.$fsname-MDT0001-*.stripesize=4M || {
2352                                 error_noexit "Setting MDT1 \"lov.stripesize\""
2353                                 return 1
2354                         }
2355                 else
2356                         $r $PERM_CMD $fsname-MDT0001.failover.node=$nid || {
2357                                 error_noexit "Setting MDT1 \"failover.node\""
2358                                 return 1
2359                         }
2360                         $r $PERM_CMD $fsname-MDT0001.mdc.max_rpcs_in_flight=9 || {
2361                                 error_noexit "Setting MDT1 \"max_rpcs_in_flight\""
2362                                 return 1
2363                         }
2364                         $r $PERM_CMD $fsname-MDT0001.lov.stripesize=4M || {
2365                                 error_noexit "Setting MDT1 \"lov.stripesize\""
2366                                 return 1
2367                         }
2368                 fi
2369         fi
2370
2371         if [ "$writeconf" ]; then
2372                 echo "== writeconf and client mount =="
2373                 $MOUNT_CMD $nid:/$fsname -o user_xattr $tmp/mnt/lustre || {
2374                         error_noexit "Mounting the client"
2375                         return 1
2376                 }
2377
2378                 shall_cleanup_lustre=true
2379                 $r $LCTL set_param debug="$PTLDEBUG"
2380
2381                 t32_verify_quota $SINGLEMDS $fsname $tmp/mnt/lustre || {
2382                         error_noexit "verify quota failed"
2383                         return 1
2384                 }
2385
2386                 if $r test -f $tmp/list; then
2387                         echo "== list verification =="
2388                         #
2389                         # There is not a Test Framework API to copy files to or
2390                         # from a remote node.
2391                         #
2392                         # LU-2393 - do both sorts on same node to ensure locale
2393                         # is identical
2394                         local list_file=$tmp/list
2395
2396                         if $mdt2_is_available; then
2397                                 if [[ -d $tmp/mnt/lustre/striped_dir_old ]] &&
2398                                    $r test -f $tmp/list2; then
2399                                         list_file=$tmp/list2
2400                                         pushd $tmp/mnt/lustre/striped_dir_old
2401                                 else
2402                                         pushd $tmp/mnt/lustre/remote_dir
2403                                 fi
2404                         else
2405                                 pushd $tmp/mnt/lustre
2406                         fi
2407                         $r cat $list_file | sort -k 6 >$tmp/list.orig
2408                         BLOCKSIZE=1024 ls -Rni --time-style=+%s | sort -k 6 |
2409                                 sed 's/\. / /' >$tmp/list || {
2410                                 error_noexit "ls"
2411                                 return 1
2412                         }
2413                         popd
2414                         #
2415                         # 32-bit and 64-bit clients use different algorithms to
2416                         # convert FIDs into inode numbers.  Hence, remove the
2417                         # inode numbers from the lists, if the original list was
2418                         # created on an architecture with different number of
2419                         # bits per "long".
2420                         #
2421                         if [ $(t32_bits_per_long $(uname -m)) != \
2422                                 $(t32_bits_per_long $img_arch) ]; then
2423                                 echo "Different number of bits per \"long\"" \
2424                                      "from the disk image"
2425                                 for list in list.orig list; do
2426                                         sed -i -e 's/^[0-9]\+[ \t]\+//' \
2427                                                   $tmp/$list
2428                                 done
2429                         fi
2430                         if ! diff -ub $tmp/list.orig $tmp/list; then
2431                                 error_noexit "list verification failed"
2432                                 return 1
2433                         fi
2434                 else
2435                         echo "== list verification skipped =="
2436                 fi
2437
2438                 #non-dom upgrade to dom
2439                 if [ "$dom_upgrade" != "no" ]; then
2440                         echo "== dom upgrade =="
2441                         $LFS setstripe -E 1M -L mdt -E EOF $tmp/mnt/lustre/dom || {
2442                                 error_noexit "Verify DoM creation"
2443                                 return 1
2444                         }
2445                         [ $($LFS getstripe -L $tmp/mnt/lustre/dom) == "mdt" ] || {
2446                                 error_noexit "Verify a DoM file"
2447                                 return 1
2448                         }
2449                         dd if=/dev/urandom of=$tmp/mnt/lustre/dom bs=4096 \
2450                                 count=1 conv=fsync || {
2451                                 error_noexit "Cannot write to DoM file"
2452                                 return 1
2453                         }
2454                         [ $(stat -c%s $tmp/mnt/lustre/dom) == 4096 ] || {
2455                                 error_noexit "DoM: bad size after write"
2456                                 return 1
2457                         }
2458                         rm $tmp/mnt/lustre/dom
2459
2460                         set_persistent_param_and_check mds \
2461                            "lod.*MDT0000*.dom_stripesize" \
2462                            "$fsname-MDT0000.lod.dom_stripesize" 0 || {
2463                                 error_noexit "Changing \"dom_stripesize\""
2464                                 return 1
2465                         }
2466                 fi
2467
2468                 #dom upgrade
2469                 #$LFS setstripe -E 1M -L mdt -E -1 -S 4M $dom_file
2470                 if [ "$dom_new_upgrade" != "no" ]; then
2471                         if ! $mdt2_is_available; then
2472                                 dom_file=$tmp/mnt/lustre/dom_dir/dom_file
2473                         fi
2474                         echo "== check DoM file can be accessed =="
2475                         [ $($LFS getstripe -I1 -L $dom_file) == "mdt" ] || {
2476                                 error_noexit "Verify a DoM file"
2477                                 return 1
2478                         }
2479                         [ $(stat -c%s $dom_file) == $((2 * 1024 * 1024)) ] || {
2480                                 error_noexit "DoM: bad size after write"
2481                                 return 1
2482                         }
2483                 fi
2484
2485                 if [ "$flr_upgrade" != "no" ]; then
2486                         if ! $mdt2_is_available; then
2487                                 flr_file=$tmp/mnt/lustre/flr_dir/flr_file
2488                         fi
2489                         local mirror_count=$($LFS getstripe -N $flr_file)
2490                         echo "== check FLR file =="
2491                         [ $mirror_count == 2 ] || {
2492                                 error_noexit "FLR mirror count wrong"
2493                                 return 1
2494                         }
2495                 fi
2496
2497                 if [ "$dne_upgrade" != "no" ]; then
2498                         echo "== dne upgrade striped_dir  =="
2499                         $LFS mkdir -i 1 -c2 $tmp/mnt/lustre/striped_dir || {
2500                                 error_noexit "set striped dir failed"
2501                                 return 1
2502                         }
2503                         $LFS setdirstripe -D -c2 $tmp/mnt/lustre/striped_dir
2504
2505                         pushd $tmp/mnt/lustre
2506                         tar -c --exclude=./striped_dir \
2507                                 --exclude=./striped_dir_old \
2508                                 --exclude=./remote_dir -f - .|
2509                                 tar -xvf - -C striped_dir 1>/dev/null || {
2510                                 error_noexit "cp to striped dir failed"
2511                                 return 1
2512                         }
2513                         popd
2514                 fi
2515
2516                 if [ "$pfl_upgrade" != "no" ]; then
2517                         local comp_size
2518                         local comp_cnt
2519                         local stripe_size
2520                         local stripe_cnt
2521                         local comp_id
2522
2523                         echo "== check PFL file =="
2524                         if ! $mdt2_is_available; then
2525                                 pfl_file=$tmp/mnt/lustre/pfl_dir/pfl_file
2526                         fi
2527                         comp_cnt=$($LFS getstripe --component-count $pfl_file)
2528                         [ $comp_cnt == 2 ] || {
2529                                 error_noexit "wrong comp_cnt $comp_cnt"
2530                                 return 1
2531                         }
2532
2533                         comp_size=$($LFS getstripe -I1 -E $pfl_file)
2534                         [ $comp_size == 2097152 ] || {
2535                                 error_noexit "wrong component size $comp_size"
2536                                 return 1
2537                         }
2538
2539                         comp_id=$($LFS getstripe -I1 -i $pfl_file)
2540                         [ $comp_id == 0 ] || {
2541                                 error_noexit "wrong comp id $comp_id"
2542                                 return 1
2543                         }
2544
2545                         comp_id=$($LFS getstripe -I2 -i $pfl_file)
2546                         [ $comp_id -eq 1 ] || {
2547                                 error_noexit "wrong comp id $comp_id"
2548                                 return 1
2549                         }
2550
2551                         stripe_size=$($LFS getstripe -I1 -S $pfl_file)
2552                         [ $stripe_size -eq 1048576 ] || {
2553                                 error_noexit "wrong stripe size $stripe_size"
2554                                 return 1
2555                         }
2556
2557                         stripe_size=$($LFS getstripe -I2 -S $pfl_file)
2558                         [ $comp_size -eq 2097152 ] || {
2559                                 error_noexit "wrong component size $comp_size"
2560                                 return 1
2561                         }
2562                 fi
2563
2564                 local large_xattr_dir=$tmp/mnt/lustre/large_xattr_test_dir
2565
2566                 if [[ -d $large_xattr_dir ]]; then
2567                         echo "== check Large EA =="
2568                         local xattr_file=$large_xattr_dir/large_xattr_file
2569
2570                         xattr_val=$(getfattr --only-values\
2571                                 -n user.fooattr $xattr_file) || {
2572                                 error_noexit "Large EA cannot be read"
2573                                 return 1
2574                         }
2575
2576                         [[ $xattr_val == $(printf "%c" {1..4096}) ]] || {
2577                                 error_noexit "Wrong large EA value"
2578                                 return 1;
2579                         }
2580                 fi
2581
2582                 if [ "$project_quota_upgrade" != "no" ]; then
2583                         if ! $mdt2_is_available; then
2584                                 quota_dir=$tmp/mnt/lustre/project_quota_dir
2585                         fi
2586                         local hardlimit
2587
2588                         echo "== check Project Quota =="
2589                         hardlimit=$(getquota -p $T32_PRJID global 3 \
2590                                                         ${tmp}/mnt/lustre)
2591                         [ $hardlimit == $T32_PROLIMIT ] || {
2592                                 error_noexit "wrong hardlimit $hardlimit"
2593                                 return 1
2594                         }
2595                 fi
2596
2597                 # If it is upgrade from DNE (2.5), then rename the remote dir,
2598                 # which is created in 2.5 to striped dir.
2599                 if $mdt2_is_available && [[ "$dne_upgrade" != "no" ]]; then
2600                         echo "== rename remote_dir =="
2601                         stripe_index=$($LFS getdirstripe -i     \
2602                                        $tmp/mnt/lustre/remote_dir)
2603
2604                         [[ $stripe_index -eq 1 ]] || {
2605                                 error_noexit "get index \"$stripe_index\"" \
2606                                              "from remote dir failed"
2607                                 return 1
2608                         }
2609                         mv $tmp/mnt/lustre/remote_dir   \
2610                                 $tmp/mnt/lustre/striped_dir/ || {
2611                                 error_noexit "mv remote dir failed"
2612                                 return 1
2613                         }
2614                 fi
2615
2616                 # If it is upgraded from DNE (2.7), then move the striped dir
2617                 # which was created in 2.7 to the new striped dir.
2618                 if $mdt2_is_available && [[ "$dne_upgrade" != "no" ]] &&
2619                         echo "== rename striped dir =="
2620                         [[ -d $tmp/mnt/lustre/striped_dir_old ]]; then
2621                         stripe_count=$($LFS getdirstripe -c     \
2622                                        $tmp/mnt/lustre/striped_dir_old)
2623                         [[ $stripe_count -eq 2 ]] || {
2624                                 error_noexit "get count $stripe_count" \
2625                                              "from striped dir failed"
2626                                 return 1
2627                         }
2628                         mv $tmp/mnt/lustre/striped_dir_old      \
2629                                 $tmp/mnt/lustre/striped_dir/ || {
2630                                 error_noexit "mv striped dir failed"
2631                                 return 1
2632                         }
2633                 fi
2634
2635                 sync; sleep 5; sync
2636                 $r $LCTL set_param -n osd*.*.force_sync=1
2637                 dd if=/dev/zero of=$tmp/mnt/lustre/tmp_file bs=10k count=10 || {
2638                         error_noexit "dd failed"
2639                         return 1
2640                 }
2641                 rm -rf $tmp/mnt/lustre/tmp_file || {
2642                         error_noexit "rm failed"
2643                         return 1
2644                 }
2645
2646                 if $r test -f $tmp/sha1sums; then
2647                         echo "== checking sha1sums =="
2648                         # LU-2393 - do both sorts on same node to ensure locale
2649                         # is identical
2650                         $r cat $tmp/sha1sums | sort -k 2 >$tmp/sha1sums.orig
2651                         if [[ "$dne_upgrade" != "no" ]]; then
2652                                 if [[ -d $tmp/mnt/lustre/striped_dir/remote_dir ]]; then
2653                                         pushd $tmp/mnt/lustre/striped_dir/remote_dir
2654                                 else
2655                                         pushd $tmp/mnt/lustre/striped_dir
2656                                 fi
2657                         elif [[ "$pfl_upgrade" != "no" ]] ||
2658                                 [[ "$flr_upgrade" != "no" ]] ||
2659                                 [[ "$dom_new_upgrade" != "no" ]] ||
2660                                 [[ "$project_quota_upgrade" != "no" ]] ||
2661                                 [[ -d $tmp/mnt/lustre/remote_dir ]]; then
2662                                 pushd $tmp/mnt/lustre/remote_dir
2663                         else
2664                                 pushd $tmp/mnt/lustre
2665                         fi
2666
2667                         find ! -path "*remote_dir*" ! -path "*striped_dir*" \
2668                              ! -name .lustre -type f -exec sha1sum {} \; |
2669                                 sort -k 2 >$tmp/sha1sums || {
2670                                 popd
2671                                 error_noexit "sha1sum"
2672                                 return 1
2673                         }
2674                         local save=$PWD
2675
2676                         popd
2677                         if ! diff -ub $tmp/sha1sums.orig $tmp/sha1sums; then
2678                                 echo "==** find $save files start **=="
2679                                 find $save -type f -ls
2680                                 echo "==** find $save files finish **=="
2681                                 error_noexit "sha1sum verification failed"
2682                                 return 1
2683                         fi
2684
2685                         # if upgrade from DNE(2.5), then check remote directory
2686                         # if upgrade from DNE(2.7), then check striped directory
2687                         if $mdt2_is_available &&
2688                            [[ "$dne_upgrade" != "no" ]]; then
2689                                 echo "== mdt2 upgrade sha1sum check =="
2690                                 local new_dir="$tmp/mnt/lustre/striped_dir"
2691                                 local striped_dir_old="$new_dir/striped_dir_old"
2692
2693                                 local dir_list="$new_dir/remote_dir"
2694                                 [[ ! -d $triped_dir_old ]] ||
2695                                         dir_list+=" $striped_dir_old"
2696
2697                                 for dir in $dir_list; do
2698                                         echo "== dir = $dir =="
2699                                         pushd $dir
2700                                         find ! -name .lustre -type f \
2701                                                 -exec sha1sum {} \; |
2702                                                 sort -k 2 >$tmp/sha1sums || {
2703                                                         ls -alR
2704                                                         popd
2705                                                         error_noexit "sha1sum"
2706                                                         return 1
2707                                                 }
2708                                         popd
2709                                         if ! diff -ub $tmp/sha1sums.orig \
2710                                                 $tmp/sha1sums; then
2711                                                 ls -alR $dir
2712                                                 error_noexit "sha1sum $dir" \
2713                                                              "failed"
2714                                                 return 1
2715                                         fi
2716                                 done
2717                         fi
2718                 else
2719                         echo "== sha1sum verification skipped =="
2720                 fi
2721
2722                 # PFL write test after sha1sum check
2723                 if [ "$pfl_upgrade" != "no" ]; then
2724                         local rw_len=$((3 * 1034 * 1024))
2725
2726                         if ! $mdt2_is_available; then
2727                                 pfl_file=$tmp/mnt/lustre/pfl_dir/pfl_file
2728                         fi
2729                         small_write $pfl_file $rw_len || {
2730                                 error_noexit "PFL RW Failed"
2731                                 return 1
2732                         }
2733                 fi
2734
2735                 if [ "$dne_upgrade" != "no" ]; then
2736                         rm -rf $tmp/mnt/lustre/striped_dir || {
2737                                 error_noexit "remove remote dir failed"
2738                                 return 1
2739                         }
2740                 fi
2741
2742                 # migrate files/dirs to remote MDT, then move them back
2743                 if [ "$MDS1_VERSION" -ge $(version_code 2.7.50) -a \
2744                      $dne_upgrade != "no" ]; then
2745                         $r $LCTL set_param -n   \
2746                                 mdt.${fsname}*.enable_remote_dir=1 2>/dev/null
2747
2748                         echo "== test migration =="
2749                         pushd $tmp/mnt/lustre
2750                         for dir in $(find ! -name .lustre ! -name . -type d); do
2751                                 mdt_index=$($LFS getdirstripe -i $dir)
2752                                 stripe_cnt=$($LFS getdirstripe -c $dir)
2753                                 if [ $mdt_index = 0 -a $stripe_cnt -le 1 ]; then
2754                                         $LFS migrate -m 1 $dir || {
2755                                         popd
2756                                         error_noexit "migrate MDT1 failed"
2757                                         return 1
2758                                 }
2759                                 fi
2760                         done
2761
2762                         for dir in $(find ! -name . ! -name .lustre -type d); do
2763                                 mdt_index=$($LFS getdirstripe -i $dir)
2764                                 stripe_cnt=$($LFS getdirstripe -c $dir)
2765                                 if [ $mdt_index = 1 -a $stripe_cnt -le 1 ]; then
2766                                         $LFS migrate -m 0 $dir || {
2767                                         popd
2768                                         error_noexit "migrate MDT0 failed"
2769                                         return 1
2770                                 }
2771                                 fi
2772                         done
2773                         popd
2774                 fi
2775
2776                 #
2777                 # When adding new data verification tests, please check for
2778                 # the presence of the required reference files first, like
2779                 # the "sha1sums" and "list" tests above, to avoid the need to
2780                 # regenerate every image for each test addition.
2781                 #
2782
2783                 nrpcs_orig=$($LCTL get_param \
2784                                 -n mdc.*MDT0000*.max_rpcs_in_flight) || {
2785                         error_noexit "Getting \"max_rpcs_in_flight\""
2786                         return 1
2787                 }
2788                 nrpcs=$((nrpcs_orig + 5))
2789
2790                 set_persistent_param_and_check client \
2791                    "mdc.$fsname-MDT0000*.max_rpcs_in_flight" \
2792                    "$fsname-MDT0000.mdc.max_rpcs_in_flight" $nrpcs || {
2793                         error_noexit "Changing \"max_rpcs_in_flight\""
2794                         return 1
2795                 }
2796
2797                 umount $tmp/mnt/lustre || {
2798                         error_noexit "Unmounting the client"
2799                         return 1
2800                 }
2801                 shall_cleanup_lustre=false
2802         else
2803                 $MOUNT_CMD $nid:/$fsname $tmp/mnt/lustre || {
2804                         error_noexit "Mounting the client"
2805                         return 1
2806                 }
2807
2808                 if [ "$mds1_FSTYPE" == ldiskfs -a \
2809                     "$project_upgrade" != "no" ]; then
2810                         ! $LFS project -d -p 1 $tmp/mnt/lustre/* &&
2811                                 error_noexit "set project failed" &&
2812                                         return 1
2813                 fi
2814
2815                 [[ $(do_facet mds1 pgrep orph_.*-MDD | wc -l) == 0 ]] ||
2816                         error "MDD orphan cleanup thread not quit"
2817
2818                 umount $tmp/mnt/lustre || {
2819                         error_noexit "Unmounting the client"
2820                         return 1
2821                 }
2822
2823                 if [[ "$dne_upgrade" != "no" ]] || $mdt2_is_available; then
2824                         $r $UMOUNT $tmp/mnt/mdt1 || {
2825                                 error_noexit "Unmounting the MDT2"
2826                                 return 1
2827                         }
2828                         if [[ "$mds1_FSTYPE" == zfs ]]; then
2829                             $r "$ZPOOL export t32fs-mdt2"
2830                         fi
2831                         shall_cleanup_mdt1=false
2832                 fi
2833
2834                 $r $UMOUNT $tmp/mnt/mdt || {
2835                         error_noexit "Unmounting the MDT"
2836                         return 1
2837                 }
2838                 if [[ "$mds1_FSTYPE" == zfs ]]; then
2839                     $r "$ZPOOL export t32fs-mdt1"
2840                 fi
2841                 shall_cleanup_mdt=false
2842
2843                 $r $UMOUNT $tmp/mnt/ost || {
2844                         error_noexit "Unmounting the OST"
2845                         return 1
2846                 }
2847                 if $ost2_is_available; then
2848                         $r $UMOUNT $tmp/mnt/ost1 || {
2849                                 error_noexit "Unmounting the OST1"
2850                                 return 1
2851                         }
2852                         shall_cleanup_ost1=false
2853                 fi
2854
2855                 if [[ $ost1_FSTYPE == zfs ]]; then
2856                         $r "$ZPOOL export t32fs-ost1"
2857                         if $ost2_is_available; then
2858                                 $r "$ZPOOL export t32fs-ost2"
2859                         fi
2860                 fi
2861                 shall_cleanup_ost=false
2862
2863                 t32_reload_modules $node || {
2864                         error_noexit "Reloading modules"
2865                         return 1
2866                 }
2867
2868                 if [[ "$mds1_FSTYPE" == zfs ]]; then
2869                         local poolname=t32fs-mdt1
2870                         $r "modprobe zfs;
2871                             $ZPOOL list -H $poolname >/dev/null 2>&1 ||
2872                                 $ZPOOL import -f -d $tmp $poolname"
2873
2874                         # upgrade zpool to latest supported features,
2875                         # including dnode quota accounting in 0.7.0
2876                         $r "$ZPOOL upgrade $poolname"
2877                 fi
2878
2879                 # mount a second time to make sure we didnt leave upgrade flag on
2880                 $r $TUNEFS --dryrun $mdt_dev || {
2881                         $r losetup -a
2882                         error_noexit "tunefs.lustre before remounting the MDT"
2883                         return 1
2884                 }
2885
2886                 mopts=exclude=$fsname-OST0000
2887                 if [ "$mds1_FSTYPE" == ldiskfs ]; then
2888                         mopts="loop,$mopts"
2889                 fi
2890                 $r $MOUNT_CMD -o $mopts $mdt_dev $tmp/mnt/mdt || {
2891                         error_noexit "Remounting the MDT"
2892                         return 1
2893                 }
2894                 shall_cleanup_mdt=true
2895         fi
2896 }
2897
2898 test_32a() {
2899         local tarballs
2900         local tarball
2901         local rc=0
2902
2903         t32_check
2904         for tarball in $tarballs; do
2905                 banner "testing $tarball upgrade"
2906                 t32_test $tarball || let "rc += $?"
2907         done
2908         return $rc
2909 }
2910 run_test 32a "Upgrade (not live)"
2911
2912 test_32b() {
2913         local tarballs
2914         local tarball
2915         local rc=0
2916
2917         t32_check
2918         for tarball in $tarballs; do
2919                 banner "testing $tarball upgrade with writeconf"
2920                 t32_test $tarball writeconf || let "rc += $?"
2921         done
2922         return $rc
2923 }
2924 run_test 32b "Upgrade with writeconf"
2925
2926 test_32c() {
2927         local tarballs
2928         local tarball
2929         local rc=0
2930
2931         t32_check
2932         for tarball in $tarballs; do
2933                 banner "testing $tarball upgrade with DNE"
2934                 load_modules
2935                 dne_upgrade=yes t32_test $tarball writeconf || rc=$?
2936         done
2937         return $rc
2938 }
2939 run_test 32c "dne upgrade test"
2940
2941 test_32d() {
2942         local tarballs
2943         local tarball
2944         local rc=0
2945
2946         t32_check
2947         for tarball in $tarballs; do
2948                 banner "testing $tarball upgrade with ff and project upgrade"
2949                 project_upgrade="no"
2950                 [[ "$MDS1_VERSION" -ge $(version_code 2.13.54) ]] &&
2951                         [[ "$tarball" =~ "disk2_4-ldiskfs" ]] &&
2952                                 project_upgrade="yes"
2953                 project_upgrade=$project_upgrade ff_convert=yes t32_test \
2954                         $tarball || rc=$?
2955         done
2956         return $rc
2957 }
2958 run_test 32d "convert ff and project quota upgrade test"
2959
2960 test_32e() {
2961         [[ "$MDS1_VERSION" -ge $(version_code 2.10.56) ]] ||
2962                 skip "Need MDS version at least 2.10.56"
2963
2964         local tarballs
2965         local tarball
2966         local rc=0
2967
2968         t32_check
2969         for tarball in $tarballs; do
2970                 [[ "$tarball" =~ "2_9" ]] ||
2971                         { echo "skip $(basename $tarball)"; continue; }
2972                 #load_modules
2973                 banner "testing $tarball upgrade with DoM"
2974                 dom_upgrade=yes t32_test $tarball writeconf || let "rc += $?"
2975         done
2976         return $rc
2977 }
2978 run_test 32e "dom upgrade test"
2979
2980 test_32f() {
2981         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
2982                 skip "Need MDS version at least 2.10.56"
2983
2984         local tarballs
2985         local tarball
2986         local rc=0
2987
2988         t32_check
2989         for tarball in $tarballs; do
2990                 [[ "$tarball" =~ "2_10" ]] ||
2991                         { echo "skip $(basename $tarball)"; continue; }
2992                 pfl_upgrade=yes project_quota_upgrade=yes \
2993                 t32_test $tarball writeconf || let "rc += $?"
2994         done
2995         return $rc
2996 }
2997 run_test 32f "pfl upgrade test"
2998
2999 test_32g() {
3000         [[ $MDS1_VERSION -ge $(version_code 2.10.56) ]] ||
3001                 skip "Need MDS version at least 2.10.56"
3002
3003         local tarballs
3004         local tarball
3005         local rc=0
3006
3007         t32_check
3008         for tarball in $tarballs; do
3009                 [[ $tarball =~ "2_12" ]] ||
3010                         { echo "skip $(basename $tarball)"; continue; }
3011                 flr_upgrade=yes dom_new_upgrade=yes \
3012                 t32_test $tarball writeconf || let "rc += $?"
3013         done
3014         return $rc
3015 }
3016 run_test 32g "flr/dom upgrade test"
3017
3018 test_33a() { # bug 12333, was test_33
3019         local FSNAME2=test-$testnum
3020
3021         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
3022         local mkfsoptions
3023
3024         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST
3025
3026         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" ]; then
3027                 local dev=${SINGLEMDS}_dev
3028                 local MDSDEV=${!dev}
3029
3030                 is_blkdev $SINGLEMDS $MDSDEV &&
3031                         skip_env "mixed loopback and real device not working"
3032         fi
3033
3034         local fs2mdsdev=$(mdsdevname 1_2)
3035         local fs2ostdev=$(ostdevname 1_2)
3036         local fs2mdsvdev=$(mdsvdevname 1_2)
3037         local fs2ostvdev=$(ostvdevname 1_2)
3038
3039         if [ "$mds1_FSTYPE" == ldiskfs ]; then
3040                 mkfsoptions="--mkfsoptions=\\\"-J size=8\\\"" # See bug 17931.
3041         fi
3042
3043         if combined_mgs_mds; then
3044                 local mgs_flag="--mgs"
3045         fi
3046
3047         add fs2mds $(mkfs_opts mds1 ${fs2mdsdev}) --fsname=${FSNAME2} \
3048                 --reformat $mgs_flag $mkfsoptions $fs2mdsdev $fs2mdsvdev ||
3049                 exit 10
3050         add fs2ost $(mkfs_opts ost1 ${fs2ostdev}) --mgsnode=$MGSNID \
3051                 --fsname=${FSNAME2} --index=0x1fff --reformat $fs2ostdev \
3052                 $fs2ostvdev || exit 10
3053
3054         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && trap cleanup_fs2 EXIT INT
3055         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
3056
3057         if [[ $PERM_CMD == *"set_param -P"* ]]; then
3058                 do_facet mgs "$PERM_CMD timeout=200" ||
3059                         error "$PERM_CMD timeout=200 failed"
3060         else
3061                 do_facet mgs "$PERM_CMD $FSNAME2.sys.timeout=200" ||
3062                         error "$PERM_CMD $FSNAME2.sys.timeout=200 failed"
3063         fi
3064         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
3065         $MOUNT_CMD $MGSNID:/${FSNAME2} $MOUNT2 || error "$MOUNT_CMD failed"
3066         echo "ok."
3067
3068         cp /etc/hosts $MOUNT2/ || error "copy /etc/hosts $MOUNT2/ failed"
3069         $LFS getstripe $MOUNT2/hosts ||
3070                 error "$LFS getstripe $MOUNT2/hosts failed"
3071
3072         umount $MOUNT2
3073
3074         if (( "$MGS_VERSION" >= $(version_code 2.15.51) &&
3075               "$MDS1_VERSION" >= $(version_code 2.15.51) )); then
3076                 # test lctl del_ost on large index
3077                 do_facet mgs "$LCTL del_ost -t ${FSNAME2}-OST1fff" ||
3078                         error "del_ost failed with $?"
3079                 $MOUNT_CMD $MGSNID:/${FSNAME2} $MOUNT2 ||
3080                         error "$MOUNT_CMD failed"
3081                 echo "ok."
3082                 $LFS df | grep -q OST1fff &&
3083                         error "del_ost did not remove OST1fff!"
3084                 umount $MOUNT2
3085         fi
3086
3087         stop fs2ost -f
3088         stop fs2mds -f
3089         cleanup_nocli || error "cleanup_nocli failed with $?"
3090 }
3091 run_test 33a "Mount ost with a large index number"
3092
3093 test_33b() {    # was test_34
3094         setup
3095
3096         do_facet client dd if=/dev/zero of=$MOUNT/24 bs=1024k count=1
3097         # Drop lock cancelation reply during umount
3098         #define OBD_FAIL_LDLM_CANCEL_NET                        0x304
3099         do_facet client $LCTL set_param fail_loc=0x80000304
3100         #lctl set_param debug=-1
3101         umount_client $MOUNT
3102         cleanup || error "cleanup failed with $?"
3103 }
3104 run_test 33b "Drop cancel during umount"
3105
3106 test_33c() {
3107         (( MDS1_VERSION >= $(version_code 2.15.57) )) ||
3108                 skip "Need MDS version at least 2.15.57"
3109         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
3110         local tstid=${TSTID:-"$(id -u $TSTUSR)"}
3111         local mkfsoptions
3112         local qpool="qpool1"
3113
3114         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST
3115
3116         local fs2mdsdev=$(mdsdevname 1_2)
3117         local fs2ostdev=$(ostdevname 1_2)
3118         local fs2mdsvdev=$(mdsvdevname 1_2)
3119         local fs2ostvdev=$(ostvdevname 1_2)
3120
3121         if [ "$mds1_FSTYPE" == ldiskfs ]; then
3122                 mkfsoptions="--mkfsoptions=\\\"-J size=8\\\"" # See bug 17931.
3123         fi
3124
3125         if combined_mgs_mds; then
3126                 local mgs_flag="--mgs"
3127         fi
3128
3129         load_modules
3130         stack_trap unload_modules_conf
3131
3132         add fs2mds $(mkfs_opts mds1 ${fs2mdsdev}) --fsname=${FSNAME} \
3133                 --reformat $mgs_flag $mkfsoptions $fs2mdsdev $fs2mdsvdev ||
3134                 exit 10
3135         add fs2ost $(mkfs_opts ost1 ${fs2ostdev}) --mgsnode=$MGSNID \
3136                 --fsname=${FSNAME} --index=0x7c6 --reformat $fs2ostdev \
3137                 $fs2ostvdev || exit 10
3138
3139
3140         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS
3141         stack_trap "stop fs2mds -f"
3142         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
3143         stack_trap "stop fs2ost -f"
3144
3145         mount_client $MOUNT || error "client start failed"
3146         stack_trap "umount_client $MOUNT"
3147         mkdir_on_mdt0 $DIR/$tdir || error "cannot create $DIR/$tdir"
3148         chmod 0777 $DIR/$tdir || error "chown failed"
3149         if [[ $PERM_CMD == *"set_param -P"* ]]; then
3150                 do_facet mgs $PERM_CMD \
3151                         osd-*.$FSNAME-OST*.quota_slave.enable=$QUOTA_TYPE
3152         else
3153                 do_facet mgs $PERM_CMD $FSNAME.quota.ost=$QUOTA_TYPE ||
3154                         error "set ost quota type failed"
3155         fi
3156
3157         local old_MDSCOUNT=$MDSCOUNT
3158         MDSCOUNT=1
3159         stack_trap "MDSCOUNT=$old_MDSCOUNT"
3160
3161         pool_add $qpool || error "pool_add failed"
3162         pool_add_targets $qpool 0x7c6
3163
3164         $LFS setquota -u $tstid -B20M -b 0 $MOUNT
3165         $LFS setquota -g $tstid -B20M -b 0 $MOUNT
3166         $LFS setquota -u $tstid -B20M -b 0 --pool $qpool $MOUNT
3167         $LFS setquota -g $tstid -B20M -b 0 --pool $qpool $MOUNT
3168
3169         for i in {1..10}; do
3170                 runas -u $tstid -g $tstid dd if=/dev/zero of=$DIR/$tdir/f1 \
3171                         bs=1M count=30 oflag=direct
3172                 sleep 3
3173                 rm -f $DIR/$tdir/f1
3174         done
3175
3176         destroy_pools
3177         #umount_client $MOUNT || error "client start failed"
3178         #stop fs2ost -f
3179         #stop fs2mds -f
3180         #cleanup_nocli || error "cleanup_nocli failed with $?"
3181 }
3182 run_test 33c "Mount ost with a large index number"
3183
3184 test_34a() {
3185         setup
3186         do_facet client "bash runmultiop_bg_pause $DIR/file O_c"
3187         manual_umount_client
3188         rc=$?
3189         do_facet client killall -USR1 multiop
3190         if [ $rc -eq 0 ]; then
3191                 error "umount not fail!"
3192         fi
3193         sleep 1
3194         cleanup || error "cleanup failed with rc $?"
3195 }
3196 run_test 34a "umount with opened file should be fail"
3197
3198 test_34b() {
3199         setup
3200         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
3201         stop_mds || error "Unable to stop MDS"
3202
3203         manual_umount_client --force || error "mtab after failed umount with $?"
3204
3205         cleanup || error "cleanup failed with $?"
3206 }
3207 run_test 34b "force umount with failed mds should be normal"
3208
3209 test_34c() {
3210         setup
3211         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
3212         stop_ost || error "Unable to stop OST1"
3213
3214         manual_umount_client --force || error "mtab after failed umount with $?"
3215
3216         cleanup || error "cleanup failed with $?"
3217 }
3218 run_test 34c "force umount with failed ost should be normal"
3219
3220 test_35a() { # bug 12459
3221         setup
3222
3223         DBG_SAVE="`$LCTL get_param -n debug`"
3224         $LCTL set_param debug="ha"
3225
3226         log "Set up a fake failnode for the MDS"
3227         FAKENID="127.0.0.2"
3228         local device=$(do_facet $SINGLEMDS "$LCTL get_param -n devices" |
3229                 awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }' | head -1)
3230
3231         if [[ $PERM_CMD == *"set_param -P"* ]]; then
3232                 do_facet mgs "$PERM_CMD \
3233                               mdc.*${device}*.import=connection=$(h2nettype $FAKENID)" ||
3234                         error "Setting mdc.*${device}*.import=connection=\
3235                                $(h2nettype $FAKENID) failed."
3236         else
3237                 do_facet mgs "$PERM_CMD \
3238                               ${device}.failover.node=$(h2nettype $FAKENID)" ||
3239                         error "Setting ${device}.failover.node=\
3240                                $(h2nettype $FAKENID) failed."
3241         fi
3242         log "Wait for RECONNECT_INTERVAL seconds (10s)"
3243         sleep 10
3244
3245         MSG="conf-sanity.sh test_35a `date +%F%kh%Mm%Ss`"
3246         $LCTL clear
3247         log "$MSG"
3248         log "Stopping the MDT: $device"
3249         stop_mdt 1 || error "MDT0 stop fail"
3250
3251         df $MOUNT > /dev/null 2>&1 &
3252         DFPID=$!
3253         log "Restarting the MDT: $device"
3254         start_mdt 1 || error "MDT0 start fail"
3255         log "Wait for df ($DFPID) ... "
3256         wait $DFPID
3257         log "done"
3258         $LCTL set_param debug="$DBG_SAVE"
3259
3260         # retrieve from the log the first server that the client tried to
3261         # contact after the connection loss
3262         $LCTL dk $TMP/lustre-log-$TESTNAME.log
3263         NEXTCONN=`awk "/${MSG}/ {start = 1;}
3264                        /import_select_connection.*$device-mdc.* using connection/ {
3265                                 if (start) {
3266                                         if (\\\$NF ~ /$FAKENID/)
3267                                                 print \\\$NF;
3268                                         else
3269                                                 print 0;
3270                                         exit;
3271                                 }
3272                        }" $TMP/lustre-log-$TESTNAME.log`
3273         [ "$NEXTCONN" != "0" ] &&
3274                 error "Tried to connect to ${NEXTCONN} not last active server"
3275         cleanup || error "cleanup failed with $?"
3276         # remove nid settings
3277         writeconf_or_reformat
3278 }
3279 run_test 35a "Reconnect to the last active server first"
3280
3281 test_35b() { # bug 18674
3282         remote_mds || skip "local MDS"
3283         setup
3284
3285         debugsave
3286         $LCTL set_param debug="ha"
3287         $LCTL clear
3288         MSG="conf-sanity.sh test_35b `date +%F%kh%Mm%Ss`"
3289         log "$MSG"
3290
3291         log "Set up a fake failnode for the MDS"
3292         FAKENID="127.0.0.2"
3293         local device=$(do_facet $SINGLEMDS "$LCTL get_param -n devices" |
3294                 awk '($3 ~ "mdt" && $4 ~ "MDT") { print $4 }' | head -1)
3295
3296         if [[ $PERM_CMD == *"set_param -P"* ]]; then
3297                 do_facet mgs "$PERM_CMD \
3298                               mdc.*${device}*.import=connection=$(h2nettype $FAKENID)" ||
3299                         error "Set mdc.*${device}*.import=connection=\
3300                                $(h2nettype $FAKENID) failed"
3301         else
3302                 do_facet mgs "$PERM_CMD \
3303                               ${device}.failover.node=$(h2nettype $FAKENID)" ||
3304                         error "Set ${device}.failover.node=\
3305                                $(h2nettype $FAKENID) failed"
3306         fi
3307
3308         local at_max_saved=0
3309         # adaptive timeouts may prevent seeing the issue
3310         if at_is_enabled; then
3311                 at_max_saved=$(at_max_get mds)
3312                 at_max_set 0 mds client
3313         fi
3314
3315         mkdir $MOUNT/$tdir || error "mkdir $MOUNT/$tdir failed"
3316
3317         log "Injecting EBUSY on MDS"
3318         # Setting OBD_FAIL_MDS_RESEND=0x136
3319         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x80000136" ||
3320                 error "unable to set param fail_loc=0x80000136"
3321
3322         $LCTL set_param mdc.${FSNAME}*.stats=clear
3323
3324         log "Creating a test file and stat it"
3325         touch $MOUNT/$tdir/$tfile || error "touch $MOUNT/$tdir/$tfile failed"
3326         stat $MOUNT/$tdir/$tfile
3327
3328         log "Stop injecting EBUSY on MDS"
3329         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0" ||
3330                 error "unable to set param fail_loc=0"
3331         rm -f $MOUNT/$tdir/$tfile || error "remove $MOUNT/$tdir/$tfile failed"
3332
3333         log "done"
3334         # restore adaptive timeout
3335         [ $at_max_saved -ne 0 ] && at_max_set $at_max_saved mds client
3336
3337         $LCTL dk $TMP/lustre-log-$TESTNAME.log
3338
3339         CONNCNT=$($LCTL get_param mdc.${FSNAME}*.stats |
3340                   awk '/mds_connect/{print $2}')
3341
3342         # retrieve from the log if the client has ever tried to
3343         # contact the fake server after the loss of connection
3344         FAILCONN=`awk "BEGIN {ret = 0;}
3345                        /import_select_connection.*${FSNAME}-MDT0000-mdc.* using connection/ {
3346                                 ret = 1;
3347                                 if (\\\$NF ~ /$FAKENID/) {
3348                                         ret = 2;
3349                                         exit;
3350                                 }
3351                        }
3352                        END {print ret}" $TMP/lustre-log-$TESTNAME.log`
3353
3354         [ "$FAILCONN" == "0" ] &&
3355                 error "The client reconnection has not been triggered"
3356         [ "$FAILCONN" == "2" ] &&
3357                 error "Primary server busy, client reconnect to failover failed"
3358
3359         # LU-290
3360         # When OBD_FAIL_MDS_RESEND is hit, we sleep for 2 * obd_timeout
3361         # Reconnects are supposed to be rate limited to one every 5s
3362         [ $CONNCNT -gt $((2 * $TIMEOUT / 5 + 1)) ] &&
3363                 error "Too many reconnects $CONNCNT"
3364
3365         cleanup || error "cleanup failed with $?"
3366         # remove nid settings
3367         writeconf_or_reformat
3368 }
3369 run_test 35b "Continue reconnection retries, if the active server is busy"
3370
3371 test_36() { # 12743
3372         [ $OSTCOUNT -lt 2 ] && skip_env "needs >= 2 OSTs"
3373
3374         [ "$ost_HOST" = "`hostname`" -o "$ost1_HOST" = "`hostname`" ] ||
3375                 skip "remote OST"
3376
3377         local rc=0
3378         local FSNAME2=test1234
3379         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
3380
3381         [ -n "$ost1_HOST" ] && fs2ost_HOST=$ost1_HOST && fs3ost_HOST=$ost1_HOST
3382
3383         if [ -z "$fs2ost_DEV" -o -z "$fs2mds_DEV" -o -z "$fs3ost_DEV" ]; then
3384                 is_blkdev $SINGLEMDS $MDSDEV &&
3385                         skip_env "mixed loopback and real device not working"
3386         fi
3387
3388         local fs2mdsdev=$(mdsdevname 1_2)
3389         local fs2ostdev=$(ostdevname 1_2)
3390         local fs3ostdev=$(ostdevname 2_2)
3391         local fs2mdsvdev=$(mdsvdevname 1_2)
3392         local fs2ostvdev=$(ostvdevname 1_2)
3393         local fs3ostvdev=$(ostvdevname 2_2)
3394
3395         load_modules
3396         add fs2mds $(mkfs_opts mds1 ${fs2mdsdev}) --mgs --fsname=${FSNAME2} \
3397                 --reformat $fs2mdsdev $fs2mdsvdev || exit 10
3398         # XXX after we support non 4K disk blocksize in ldiskfs, specify a
3399         #     different one than the default value here.
3400         add fs2ost $(mkfs_opts ost1 ${fs2ostdev}) --mgsnode=$MGSNID \
3401                 --fsname=${FSNAME2} --reformat $fs2ostdev $fs2ostvdev || exit 10
3402         add fs3ost $(mkfs_opts ost2 ${fs3ostdev}) --mgsnode=$MGSNID \
3403                 --fsname=${FSNAME2} --reformat $fs3ostdev $fs3ostvdev || exit 10
3404
3405         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS
3406         start fs2ost $fs2ostdev $OST_MOUNT_OPTS
3407         start fs3ost $fs3ostdev $OST_MOUNT_OPTS
3408         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
3409         $MOUNT_CMD $MGSNID:/${FSNAME2} $MOUNT2 || error "$MOUNT_CMD failed"
3410
3411         sleep 5 # until 11778 fixed
3412
3413         dd if=/dev/zero of=$MOUNT2/$tfile bs=1M count=7 || error "dd failed"
3414
3415         BKTOTAL=$($LCTL get_param -n obdfilter.*.kbytestotal |
3416                   awk 'BEGIN{total=0}; {total+=$1}; END{print total}')
3417         BKFREE=$($LCTL get_param -n obdfilter.*.kbytesfree |
3418                  awk 'BEGIN{free=0}; {free+=$1}; END{print free}')
3419         BKAVAIL=$($LCTL get_param -n obdfilter.*.kbytesavail |
3420                   awk 'BEGIN{avail=0}; {avail+=$1}; END{print avail}')
3421         STRING=$(df -P $MOUNT2 | tail -n 1 | awk '{print $2","$3","$4}')
3422         DFTOTAL=$(echo $STRING | cut -d, -f1)
3423         DFUSED=$(echo $STRING  | cut -d, -f2)
3424         DFAVAIL=$(echo $STRING | cut -d, -f3)
3425         DFFREE=$(($DFTOTAL - $DFUSED))
3426
3427         ALLOWANCE=$((64 * $OSTCOUNT))
3428
3429         if [ $DFTOTAL -lt $(($BKTOTAL - $ALLOWANCE)) ] ||
3430            [ $DFTOTAL -gt $(($BKTOTAL + $ALLOWANCE)) ] ; then
3431                 echo "**** FAIL: df total($DFTOTAL) mismatch OST total($BKTOTAL)"
3432                 rc=1
3433         fi
3434         if [ $DFFREE -lt $(($BKFREE - $ALLOWANCE)) ] ||
3435            [ $DFFREE -gt $(($BKFREE + $ALLOWANCE)) ] ; then
3436                 echo "**** FAIL: df free($DFFREE) mismatch OST free($BKFREE)"
3437                 rc=2
3438         fi
3439         if [ $DFAVAIL -lt $(($BKAVAIL - $ALLOWANCE)) ] ||
3440            [ $DFAVAIL -gt $(($BKAVAIL + $ALLOWANCE)) ] ; then
3441                 echo "**** FAIL: df avail($DFAVAIL) mismatch OST avail($BKAVAIL)"
3442                 rc=3
3443         fi
3444
3445         $UMOUNT $MOUNT2
3446         stop fs3ost -f || error "unable to stop OST3"
3447         stop fs2ost -f || error "unable to stop OST2"
3448         stop fs2mds -f || error "unable to stop second MDS"
3449         unload_modules_conf || error "unable unload modules"
3450         return $rc
3451 }
3452 run_test 36 "df report consistency on OSTs with different block size"
3453
3454 test_37() {
3455         local mntpt=$(facet_mntpt $SINGLEMDS)
3456         local mdsdev=$(mdsdevname ${SINGLEMDS//mds/})
3457         local mdsdev_sym="$TMP/sym_mdt.img"
3458         local opts=$MDS_MOUNT_OPTS
3459         local rc=0
3460
3461         if [ "$mds1_FSTYPE" != ldiskfs ]; then
3462                 skip "ldiskfs only test"
3463         fi
3464
3465         echo "MDS :     $mdsdev"
3466         echo "SYMLINK : $mdsdev_sym"
3467         do_facet $SINGLEMDS rm -f $mdsdev_sym
3468
3469         do_facet $SINGLEMDS ln -s $mdsdev $mdsdev_sym
3470
3471         echo "mount symlink device - $mdsdev_sym"
3472
3473         if ! do_facet $SINGLEMDS test -b $mdsdev; then
3474                 opts=$(csa_add "$opts" -o loop)
3475         fi
3476
3477         load_modules
3478         mount_op=$(do_facet $SINGLEMDS mount -v -t lustre $opts \
3479                 $mdsdev_sym $mntpt 2>&1)
3480         rc=${PIPESTATUS[0]}
3481
3482         echo mount_op=$mount_op
3483
3484         do_facet $SINGLEMDS "$UMOUNT $mntpt && rm -f $mdsdev_sym"
3485
3486         if $(echo $mount_op | grep -q "unable to set tunable"); then
3487                 error "set tunables failed for symlink device"
3488         fi
3489
3490         [ $rc -eq 0 ] || error "mount symlink $mdsdev_sym failed! rc=$rc"
3491 }
3492 run_test 37 "verify set tunables works for symlink device"
3493
3494 test_38() { # bug 14222
3495         local mntpt=$(facet_mntpt $SINGLEMDS)
3496
3497         setup
3498         # like runtests
3499         local COUNT=10
3500         local SRC="/etc /bin"
3501         local FILES=$(find $SRC -type f -mtime +1 | head -n $COUNT)
3502
3503         log "copying $(echo $FILES | wc -w) files to $DIR/$tdir"
3504         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
3505         tar cf - $FILES | tar xf - -C $DIR/$tdir ||
3506                 error "copying $SRC to $DIR/$tdir"
3507         sync
3508         umount_client $MOUNT || error "umount_client $MOUNT failed"
3509         do_facet $SINGLEMDS "$LCTL get_param osp.*.prealloc_next_id"
3510         stop_mds || error "Unable to stop MDS"
3511         log "delete lov_objid file on MDS"
3512
3513         mount_fstype $SINGLEMDS || error "mount MDS failed (1)"
3514
3515         do_facet $SINGLEMDS "od -Ax -td8 $mntpt/lov_objid; rm $mntpt/lov_objid"
3516
3517         unmount_fstype $SINGLEMDS || error "umount failed (1)"
3518
3519         # check create in mds_lov_connect
3520         start_mds || error "unable to start MDS"
3521         mount_client $MOUNT || error "mount_client $MOUNT failed"
3522         for f in $FILES; do
3523                 [ $V ] && log "verifying $DIR/$tdir/$f"
3524                 diff -q $f $DIR/$tdir/$f || ERROR=y
3525         done
3526         do_facet $SINGLEMDS "$LCTL get_param osp.*.prealloc_next_id"
3527         if [ "$ERROR" = "y" ]; then
3528                 # check it's updates in sync
3529                 umount_client $MOUNT
3530                 stop_mds
3531                 mount_fstype $SIGNLEMDS
3532                 do_facet $SINGLEMDS "od -Ax -td8 $mntpt/lov_objid"
3533                 unmount_fstype $SINGLEMDS
3534                 error "old and new files are different after connect" || true
3535         fi
3536         touch $DIR/$tdir/f2 || error "f2 file create failed"
3537
3538         # check it's updates in sync
3539         umount_client $MOUNT || error "second umount_client $MOUNT failed"
3540         stop_mds
3541
3542         mount_fstype $SINGLEMDS || error "mount MDS failed (3)"
3543
3544         do_facet $SINGLEMDS "od -Ax -td8 $mntpt/lov_objid"
3545         do_facet $SINGLEMDS dd if=/dev/zero of=$mntpt/lov_objid.clear count=8
3546
3547         unmount_fstype $SINGLEMDS || error "umount failed (3)"
3548
3549         start_mds || error "unable to start MDS"
3550         mount_client $MOUNT || error "mount_client $MOUNT failed"
3551         for f in $FILES; do
3552                 [ $V ] && log "verifying $DIR/$tdir/$f"
3553                 diff -q $f $DIR/$tdir/$f || ERROR=y
3554         done
3555         touch $DIR/$tdir/f3 || error "f3 file create failed"
3556         do_facet $SINGLEMDS "$LCTL get_param osp.*.prealloc_next_id"
3557         umount_client $MOUNT || error "third umount_client $MOUNT failed"
3558         stop_mds
3559         mount_fstype $SINGLEMDS || error "mount MDS failed (4)"
3560         do_facet $SINGLEMDS "od -Ax -td8 $mntpt/lov_objid"
3561         unmount_fstype $SINGLEMDS || error "umount failed (4)"
3562
3563         [[ "$ERROR" != "y" ]] ||
3564                 error "old and new files are different after sync"
3565
3566         log "files compared the same"
3567         cleanup || error "cleanup failed with $?"
3568 }
3569 run_test 38 "MDS recreates missing lov_objid file from OST data"
3570
3571 test_39() {
3572         [[ -n "$(type -p perl)" ]] || skip_env "need perl for leak_finder.pl"
3573
3574         PTLDEBUG=+malloc
3575         setup
3576         cleanup || error "cleanup failed with $?"
3577         perl $SRCDIR/leak_finder.pl $TMP/debug 2>&1 | egrep '*** Leak:' &&
3578                 error "memory leak detected" || true
3579 }
3580 run_test 39 "leak_finder recognizes both LUSTRE and LNET malloc messages"
3581
3582 test_40() { # bug 15759
3583         start_ost || error "Unable to start OST1"
3584         #define OBD_FAIL_TGT_TOOMANY_THREADS     0x706
3585         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x80000706"
3586         start_mds
3587         cleanup || error "cleanup failed with rc $?"
3588 }
3589 run_test 40 "race during service thread startup"
3590
3591 test_41a() { #bug 14134
3592         if [ "$mds1_FSTYPE" == ldiskfs ] &&
3593            ! do_facet $SINGLEMDS test -b $(mdsdevname 1); then
3594                 skip "Loop devices does not work with nosvc option"
3595         fi
3596
3597         combined_mgs_mds || skip "needs combined MGT and MDT device"
3598
3599         start_mdt 1 -o nosvc -n
3600         if [ $MDSCOUNT -ge 2 ]; then
3601                 for num in $(seq 2 $MDSCOUNT); do
3602                         start_mdt $num || return
3603                 done
3604         fi
3605         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS
3606         start_mdt 1 -o nomgs,force
3607         mount_client $MOUNT || error "mount_client $MOUNT failed"
3608         sleep 5
3609
3610         echo "blah blah" > $MOUNT/$tfile
3611         cat $MOUNT/$tfile
3612
3613         umount_client $MOUNT || error "umount_client $MOUNT failed"
3614         stop ost1 -f || error "unable to stop OST1"
3615         stop_mds || error "Unable to stop MDS"
3616         stop_mds || error "Unable to stop MDS on second try"
3617 }
3618 run_test 41a "mount mds with --nosvc and --nomgs"
3619
3620 test_41b() {
3621         if [ "$mds1_FSTYPE" == ldiskfs ] &&
3622            ! do_facet $SINGLEMDS test -b $(mdsdevname 1); then
3623                 skip "Loop devices does not work with nosvc option"
3624         fi
3625
3626         ! combined_mgs_mds && skip "needs combined mgs device"
3627
3628         stopall
3629         reformat
3630         local MDSDEV=$(mdsdevname ${SINGLEMDS//mds/})
3631
3632         start_mdt 1 -o nosvc -n
3633         if [ $MDSCOUNT -ge 2 ]; then
3634                 for num in $(seq 2 $MDSCOUNT); do
3635                         start_mdt $num || return
3636                 done
3637         fi
3638         start_ost || error "Unable to start OST1"
3639         start_mdt 1 -o nomgs,force
3640         mount_client $MOUNT || error "mount_client $MOUNT failed"
3641         sleep 5
3642
3643         echo "blah blah" > $MOUNT/$tfile
3644         cat $MOUNT/$tfile || error "cat $MOUNT/$tfile failed"
3645
3646         umount_client $MOUNT -f || error "umount_client $MOUNT failed"
3647         stop_ost || error "Unable to stop OST1"
3648         stop_mds || error "Unable to stop MDS"
3649         stop_mds || error "Unable to stop MDS on second try"
3650 }
3651 run_test 41b "mount mds with --nosvc and --nomgs on first mount"
3652
3653 test_41c() {
3654         local oss_list=$(comma_list $(osts_nodes))
3655
3656         [[ "$MDS1_VERSION" -ge $(version_code 2.6.52) ]] ||
3657         [[ "$MDS1_VERSION" -ge $(version_code 2.5.26) &&
3658            "$MDS1_VERSION" -lt $(version_code 2.5.50) ]] ||
3659         [[ "$MDS1_VERSION" -ge $(version_code 2.5.4) &&
3660            "$MDS1_VERSION" -lt $(version_code 2.5.11) ]] ||
3661                 skip "Need MDS version 2.5.4+ or 2.5.26+ or 2.6.52+"
3662
3663         # ensure mds1 ost1 have been created even if running sub-test standalone
3664         cleanup
3665         setup
3666         cleanup || error "cleanup failed"
3667
3668         # using directly mount command instead of start() function to avoid
3669         # any side effect of // with others/externals tools/features
3670         # ("zpool import", ...)
3671
3672         # MDT concurrent start
3673
3674         LOAD_MODULES_REMOTE=true load_modules
3675         do_facet $SINGLEMDS "lsmod | grep -q libcfs" ||
3676                 error "MDT concurrent start: libcfs module not loaded"
3677
3678         local mds1dev=$(mdsdevname 1)
3679         local mds1mnt=$(facet_mntpt mds1)
3680         local mds1opts=$MDS_MOUNT_OPTS
3681
3682         if [ "$mds1_FSTYPE" == ldiskfs ] &&
3683            ! do_facet mds1 test -b $mds1dev; then
3684                 mds1opts=$(csa_add "$mds1opts" -o loop)
3685         fi
3686         if [[ "$mds1_FSTYPE" == zfs ]]; then
3687                 import_zpool mds1 || return ${PIPESTATUS[0]}
3688         fi
3689
3690         #define OBD_FAIL_TGT_MOUNT_RACE 0x716
3691         do_facet mds1 "$LCTL set_param fail_loc=0x80000716"
3692
3693         do_facet mds1 mount -t lustre $mds1dev $mds1mnt $mds1opts &
3694         local pid=$!
3695
3696         do_facet mds1 mount -t lustre $mds1dev $mds1mnt $mds1opts
3697         local rc2=$?
3698         wait $pid
3699         local rc=$?
3700
3701         do_facet mds1 "$LCTL set_param fail_loc=0x0"
3702         if [ $rc -eq 0 ] && [ $rc2 -ne 0 ]; then
3703                 echo "1st MDT start succeed"
3704                 echo "2nd MDT start failed with $rc2"
3705         elif [ $rc2 -eq 0 ] && [ $rc -ne 0 ]; then
3706                 echo "1st MDT start failed with $rc"
3707                 echo "2nd MDT start succeed"
3708         else
3709                 stop mds1 -f
3710                 error "unexpected concurrent MDT mounts result, rc=$rc rc2=$rc2"
3711         fi
3712
3713         if [ $MDSCOUNT -ge 2 ]; then
3714                 for num in $(seq 2 $MDSCOUNT); do
3715                         start_mdt $num || return
3716                 done
3717         fi
3718
3719         # OST concurrent start
3720
3721         do_rpc_nodes $oss_list "lsmod | grep -q libcfs" ||
3722                 error "OST concurrent start: libcfs module not loaded"
3723
3724         local ost1dev=$(ostdevname 1)
3725         local ost1mnt=$(facet_mntpt ost1)
3726         local ost1opts=$OST_MOUNT_OPTS
3727
3728         if [ "$ost1_FSTYPE" == ldiskfs ] &&
3729            ! do_facet ost1 test -b $ost1dev; then
3730                 ost1opts=$(csa_add "$ost1opts" -o loop)
3731         fi
3732         if [[ "$ost1_FSTYPE" == zfs ]]; then
3733                 import_zpool ost1 || return ${PIPESTATUS[0]}
3734         fi
3735
3736         #define OBD_FAIL_TGT_MOUNT_RACE 0x716
3737         do_facet ost1 "$LCTL set_param fail_loc=0x80000716"
3738
3739         do_facet ost1 mount -t lustre $ost1dev $ost1mnt $ost1opts &
3740         pid=$!
3741
3742         do_facet ost1 mount -t lustre $ost1dev $ost1mnt $ost1opts
3743         rc2=$?
3744         wait $pid
3745         rc=$?
3746         do_facet ost1 "$LCTL set_param fail_loc=0x0"
3747         if [ $rc -eq 0 ] && [ $rc2 -ne 0 ]; then
3748                 echo "1st OST start succeed"
3749                 echo "2nd OST start failed with $rc2"
3750         elif [ $rc2 -eq 0 ] && [ $rc -ne 0 ]; then
3751                 echo "1st OST start failed with $rc"
3752                 echo "2nd OST start succeed"
3753         else
3754                 stop_mds -f
3755                 stop ost1 -f
3756                 error "unexpected concurrent OST mounts result, rc=$rc rc2=$rc2"
3757         fi
3758         # cleanup
3759         stop_mds
3760         stop ost1 -f
3761
3762         # verify everything ok
3763         start_mds
3764         if [ $? != 0 ]
3765         then
3766                 stop_mds
3767                 error "MDT(s) start failed"
3768         fi
3769
3770         start_ost
3771         if [ $? != 0 ]
3772         then
3773                 stop_mds
3774                 stop ost1 -f
3775                 error "OST(s) start failed"
3776         fi
3777
3778         mount_client $MOUNT
3779         if [ $? != 0 ]
3780         then
3781                 stop_mds
3782                 stop ost1 -f
3783                 error "client start failed"
3784         fi
3785         check_mount
3786         if [ $? != 0 ]
3787         then
3788                 stop_mds
3789                 stop ost1 -f
3790                 error "client mount failed"
3791         fi
3792         cleanup
3793 }
3794 run_test 41c "concurrent mounts of MDT/OST should all fail but one"
3795
3796 test_42() { #bug 14693
3797         local PARAM
3798
3799         setup
3800         check_mount || error "client was not mounted"
3801
3802         if [[ $PERM_CMD == *"set_param -P"* ]]; then
3803                 PARAM="llite.$FSNAME-*.some_wrong_param"
3804         else
3805                 PARAM="$FSNAME.llite.some_wrong_param"
3806         fi
3807
3808         do_facet mgs $PERM_CMD $PARAM=10
3809         umount_client $MOUNT ||
3810                 error "unmounting client failed with invalid llite param"
3811         mount_client $MOUNT ||
3812                 error "mounting client failed with invalid llite param"
3813
3814         do_facet mgs $PERM_CMD $PARAM=20
3815         cleanup || error "stopping $FSNAME failed with invalid sys param"
3816         setup
3817         check_mount || error "client was not mounted with invalid sys param"
3818         cleanup || error "stopping $FSNAME failed with invalid sys param"
3819 }
3820 run_test 42 "allow client/server mount/unmount with invalid config param"
3821
3822 test_43a() {
3823         [[ "$MGS_VERSION" -ge $(version_code 2.5.58) ]] ||
3824                 skip "Need MDS version at least 2.5.58"
3825         [ $UID -ne 0 -o $RUNAS_ID -eq 0 ] && skip_env "run as root"
3826
3827         ID1=${ID1:-501}
3828         USER1=$(getent passwd | grep :$ID1:$ID1: | cut -d: -f1)
3829         [ -z "$USER1" ] && skip_env "missing user with uid=$ID1 gid=$ID1"
3830
3831         setup
3832         chmod ugo+x $DIR || error "chmod 0 failed"
3833         set_persistent_param_and_check mds1                             \
3834                 "mdt.$FSNAME-MDT0000.root_squash"                       \
3835                 "$FSNAME.mdt.root_squash"                               \
3836                 "0:0"
3837         wait_update $HOSTNAME                                           \
3838                 "$LCTL get_param -n llite.${FSNAME}*.root_squash"       \
3839                 "0:0" ||
3840                 error "check llite root_squash failed!"
3841         set_persistent_param_and_check mds1                             \
3842                 "mdt.$FSNAME-MDT0000.nosquash_nids"                     \
3843                 "$FSNAME.mdt.nosquash_nids"                             \
3844                 "NONE"
3845         wait_update $HOSTNAME                                           \
3846                 "$LCTL get_param -n llite.${FSNAME}*.nosquash_nids"     \
3847                 "NONE" ||
3848                 error "check llite nosquash_nids failed!"
3849
3850         #
3851         # create set of test files
3852         #
3853         echo "111" > $DIR/$tfile-userfile || error "write 1 failed"
3854         chmod go-rw $DIR/$tfile-userfile  || error "chmod 1 failed"
3855         chown $RUNAS_ID.$RUNAS_ID $DIR/$tfile-userfile || error "chown failed"
3856
3857         echo "222" > $DIR/$tfile-rootfile || error "write 2 failed"
3858         chmod go-rw $DIR/$tfile-rootfile  || error "chmod 2 faield"
3859
3860         mkdir_on_mdt0 $DIR/$tdir-rootdir || error "mkdir failed"
3861         chmod go-rwx $DIR/$tdir-rootdir || error "chmod 3 failed"
3862         touch $DIR/$tdir-rootdir/tfile-1 || error "touch failed"
3863
3864         echo "777" > $DIR/$tfile-user1file || error "write 7 failed"
3865         chmod go-rw $DIR/$tfile-user1file || error "chmod 7 failed"
3866         chown $ID1.$ID1 $DIR/$tfile-user1file || error "chown failed"
3867
3868         #
3869         # check root_squash:
3870         #   set root squash UID:GID to RUNAS_ID
3871         #   root should be able to access only files owned by RUNAS_ID
3872         #
3873         set_persistent_param_and_check mds1                             \
3874                 "mdt.$FSNAME-MDT0000.root_squash"                       \
3875                 "$FSNAME.mdt.root_squash"                               \
3876                 "$RUNAS_ID:$RUNAS_ID"
3877         wait_update $HOSTNAME                                           \
3878                 "$LCTL get_param -n llite.${FSNAME}*.root_squash"       \
3879                 "$RUNAS_ID:$RUNAS_ID" ||
3880                 error "check llite root_squash failed!"
3881
3882         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tfile-userfile)
3883         dd if=$DIR/$tfile-userfile 1>/dev/null 2>/dev/null ||
3884                 error "$ST: root read permission is denied"
3885         echo "$ST: root read permission is granted - ok"
3886
3887         echo "444" |
3888         dd conv=notrunc of=$DIR/$tfile-userfile 1>/dev/null 2>/dev/null ||
3889                 error "$ST: root write permission is denied"
3890         echo "$ST: root write permission is granted - ok"
3891
3892         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tfile-rootfile)
3893         dd if=$DIR/$tfile-rootfile 1>/dev/null 2>/dev/null &&
3894                 error "$ST: root read permission is granted"
3895         echo "$ST: root read permission is denied - ok"
3896
3897         echo "555" |
3898         dd conv=notrunc of=$DIR/$tfile-rootfile 1>/dev/null 2>/dev/null &&
3899                 error "$ST: root write permission is granted"
3900         echo "$ST: root write permission is denied - ok"
3901
3902         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tdir-rootdir)
3903                 rm $DIR/$tdir-rootdir/tfile-1 1>/dev/null 2>/dev/null &&
3904                         error "$ST: root unlink permission is granted"
3905         echo "$ST: root unlink permission is denied - ok"
3906
3907         touch $DIR/tdir-rootdir/tfile-2 1>/dev/null 2>/dev/null &&
3908                 error "$ST: root create permission is granted"
3909         echo "$ST: root create permission is denied - ok"
3910
3911         # LU-1778
3912         # check root_squash is enforced independently
3913         # of client cache content
3914         #
3915         # access file by USER1, keep access open
3916         # root should be denied access to user file
3917
3918         runas -u $ID1 tail -f $DIR/$tfile-user1file 1>/dev/null 2>&1 &
3919         pid=$!
3920         sleep 1
3921
3922         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tfile-user1file)
3923         dd if=$DIR/$tfile-user1file 1>/dev/null 2>&1 &&
3924             { kill $pid; error "$ST: root read permission is granted"; }
3925         echo "$ST: root read permission is denied - ok"
3926
3927         echo "777" |
3928         dd conv=notrunc of=$DIR/$tfile-user1file 1>/dev/null 2>&1 &&
3929             { kill $pid; error "$ST: root write permission is granted"; }
3930         echo "$ST: root write permission is denied - ok"
3931
3932         kill $pid
3933         wait $pid
3934
3935         #
3936         # check nosquash_nids:
3937         #   put client's NID into nosquash_nids list,
3938         #   root should be able to access root file after that
3939         #
3940         local NIDLIST=$($LCTL list_nids all | tr '\n' ' ')
3941         NIDLIST="2@gni $NIDLIST 192.168.0.[2,10]@tcp"
3942         NIDLIST=$(echo $NIDLIST | tr -s ' ' ' ')
3943         set_persistent_param_and_check mds1                             \
3944                 "mdt.$FSNAME-MDT0000.nosquash_nids"                     \
3945                 "$FSNAME-MDTall.mdt.nosquash_nids"                      \
3946                 "$NIDLIST"
3947         wait_update $HOSTNAME                                           \
3948                 "$LCTL get_param -n llite.${FSNAME}*.nosquash_nids"     \
3949                 "$NIDLIST" ||
3950                 error "check llite nosquash_nids failed!"
3951
3952         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tfile-rootfile)
3953         dd if=$DIR/$tfile-rootfile 1>/dev/null 2>/dev/null ||
3954                 error "$ST: root read permission is denied"
3955         echo "$ST: root read permission is granted - ok"
3956
3957         echo "666" |
3958         dd conv=notrunc of=$DIR/$tfile-rootfile 1>/dev/null 2>/dev/null ||
3959                 error "$ST: root write permission is denied"
3960         echo "$ST: root write permission is granted - ok"
3961
3962         ST=$(stat -c "%n: owner uid %u (%A)" $DIR/$tdir-rootdir)
3963         rm $DIR/$tdir-rootdir/tfile-1 ||
3964                 error "$ST: root unlink permission is denied"
3965         echo "$ST: root unlink permission is granted - ok"
3966         touch $DIR/$tdir-rootdir/tfile-2 ||
3967                 error "$ST: root create permission is denied"
3968         echo "$ST: root create permission is granted - ok"
3969         cleanup || error "cleanup failed with $?"
3970 }
3971 run_test 43a "check root_squash and nosquash_nids"
3972
3973 test_43b() { # LU-5690
3974         [[ "$MGS_VERSION" -ge $(version_code 2.7.62) ]] ||
3975                 skip "Need MGS version 2.7.62+"
3976
3977         if [[ -z "$fs2mds_DEV" ]]; then
3978                 is_blkdev $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) &&
3979                 skip_env "mixed loopback and real device not working"
3980         fi
3981
3982         local fs2mdsdev=$(mdsdevname 1_2)
3983         local fs2mdsvdev=$(mdsvdevname 1_2)
3984
3985         # temporarily use fs2mds as fs2mgs
3986         local fs2mgs=fs2mds
3987         local fs2mgsdev=$fs2mdsdev
3988         local fs2mgsvdev=$fs2mdsvdev
3989
3990         local fsname=test1234
3991
3992         load_module llite/lustre
3993         local client_ip=$(host_nids_address $HOSTNAME $NETTYPE)
3994         local host=${client_ip//*./}
3995         local net=${client_ip/%$host/}
3996         local nosquash_nids=$(h2nettype $net[$host,$host,$host])
3997
3998         add $fs2mgs $(mkfs_opts mgs $fs2mgsdev) --fsname=$fsname \
3999                 --param mdt.root_squash=$RUNAS_ID:$RUNAS_ID \
4000                 --param mdt.nosquash_nids=$nosquash_nids \
4001                 --reformat $fs2mgsdev $fs2mgsvdev || error "add fs2mgs failed"
4002         start $fs2mgs $fs2mgsdev $MGS_MOUNT_OPTS  || error "start fs2mgs failed"
4003         stop $fs2mgs -f || error "stop fs2mgs failed"
4004         cleanup || error "cleanup failed with $?"
4005 }
4006 run_test 43b "parse nosquash_nids with commas in expr_list"
4007
4008 test_44() { # 16317
4009         setup
4010         check_mount || error "check_mount"
4011         UUID=$($LCTL get_param llite.${FSNAME}*.uuid | cut -d= -f2)
4012         STATS_FOUND=no
4013         UUIDS=$(do_facet $SINGLEMDS "$LCTL get_param mdt.${FSNAME}*.exports.*.uuid")
4014         for VAL in $UUIDS; do
4015                 NID=$(echo $VAL | cut -d= -f1)
4016                 CLUUID=$(echo $VAL | cut -d= -f2)
4017                 [ "$UUID" = "$CLUUID" ] && STATS_FOUND=yes && break
4018         done
4019         [ "$STATS_FOUND" = "no" ] && error "stats not found for client"
4020         cleanup || error "cleanup failed with $?"
4021 }
4022 run_test 44 "mounted client proc entry exists"
4023
4024 test_45() { #17310
4025         setup
4026         check_mount || error "check_mount"
4027         stop_mds || error "Unable to stop MDS"
4028         df -h $MOUNT &
4029         log "sleep 60 sec"
4030         sleep 60
4031         #define OBD_FAIL_PTLRPC_LONG_REPL_UNLINK        0x50f
4032         do_facet client "$LCTL set_param fail_loc=0x8000050f"
4033         log "sleep 10 sec"
4034         sleep 10
4035         manual_umount_client --force || error "manual_umount_client failed"
4036         do_facet client "$LCTL set_param fail_loc=0x0"
4037         start_mds || error "unable to start MDS"
4038         mount_client $MOUNT || error "mount_client $MOUNT failed"
4039         cleanup || error "cleanup failed with $?"
4040 }
4041 run_test 45 "long unlink handling in ptlrpcd"
4042
4043 cleanup_46a() {
4044         trap 0
4045         local rc=0
4046         local count=$1
4047
4048         umount_client $MOUNT2 || rc=$?
4049         umount_client $MOUNT || rc=$?
4050         while [ $count -gt 0 ]; do
4051                 stop ost${count} -f || rc=$?
4052                 let count=count-1
4053         done
4054         stop_mds || rc=$?
4055         cleanup_nocli || rc=$?
4056         #writeconf to remove all ost2 traces for subsequent tests
4057         writeconf_or_reformat
4058         return $rc
4059 }
4060
4061 test_46a() {
4062         echo "Testing with $OSTCOUNT OSTs"
4063         reformat_and_config
4064         start_mds || error "unable to start MDS"
4065         #first client should see only one ost
4066         start_ost || error "Unable to start OST1"
4067         wait_osc_import_state mds ost FULL
4068         #start_client
4069         mount_client $MOUNT || error "mount_client $MOUNT failed"
4070         trap "cleanup_46a $OSTCOUNT" EXIT ERR
4071
4072         local i
4073         for (( i=2; i<=$OSTCOUNT; i++ )); do
4074                 start ost$i $(ostdevname $i) $OST_MOUNT_OPTS ||
4075                         error "start_ost$i $(ostdevname $i) failed"
4076         done
4077
4078         # wait until osts in sync
4079         for (( i=2; i<=$OSTCOUNT; i++ )); do
4080             wait_osc_import_state mds ost$i FULL
4081             wait_osc_import_ready client ost$i
4082         done
4083
4084         #second client see all ost's
4085
4086         mount_client $MOUNT2 || error "mount_client failed"
4087         $LFS setstripe -c -1 $MOUNT2 ||
4088                 error "$LFS setstripe -c -1 $MOUNT2 failed"
4089         $LFS getstripe $MOUNT2 || error "$LFS getstripe $MOUNT2 failed"
4090
4091         echo "ok" > $MOUNT2/widestripe
4092         $LFS getstripe $MOUNT2/widestripe ||
4093                 error "$LFS getstripe $MOUNT2/widestripe failed"
4094         # fill acl buffer for avoid expand lsm to them
4095         awk -F : '{if (FNR < 25) { print "u:"$1":rwx" }}' /etc/passwd |
4096                 while read acl; do
4097             setfacl -m $acl $MOUNT2/widestripe
4098         done
4099
4100         # will be deadlock
4101         stat $MOUNT/widestripe || error "stat $MOUNT/widestripe failed"
4102
4103         cleanup_46a $OSTCOUNT || error "cleanup_46a failed"
4104 }
4105 run_test 46a "handle ost additional - wide striped file"
4106
4107 test_47() { #17674
4108         reformat
4109         setup_noconfig
4110         check_mount || error "check_mount failed"
4111         $LCTL set_param ldlm.namespaces.$FSNAME-*-*-*.lru_size=100
4112
4113         local lru_size=[]
4114         local count=0
4115         for ns in $($LCTL get_param ldlm.namespaces.$FSNAME-*-*-*.lru_size); do
4116                 if echo $ns | grep "MDT[[:digit:]]*"; then
4117                         continue
4118                 fi
4119                 lrs=$(echo $ns | sed 's/.*lru_size=//')
4120                 lru_size[count]=$lrs
4121                 let count=count+1
4122         done
4123
4124         facet_failover ost1
4125         facet_failover $SINGLEMDS
4126         client_up || error "client_up failed"
4127
4128         count=0
4129         for ns in $($LCTL get_param ldlm.namespaces.$FSNAME-*-*-*.lru_size); do
4130                 if echo $ns | grep "MDT[[:digit:]]*"; then
4131                         continue
4132                 fi
4133                 lrs=$(echo $ns | sed 's/.*lru_size=//')
4134                 if ! test "$lrs" -eq "${lru_size[count]}"; then
4135                         n=$(echo $ns | sed -e 's/ldlm.namespaces.//' -e 's/.lru_size=.*//')
4136                         error "$n has lost lru_size: $lrs vs. ${lru_size[count]}"
4137                 fi
4138                 let count=count+1
4139         done
4140
4141         cleanup || error "cleanup failed with $?"
4142 }
4143 run_test 47 "server restart does not make client loss lru_resize settings"
4144
4145 cleanup_48() {
4146         trap 0
4147
4148         # reformat after this test is needed - if the test fails,
4149         # we will have unkillable file at FS
4150         reformat_and_config
4151 }
4152
4153 test_48() { # bz-17636 LU-7473
4154         local count
4155
4156         setup_noconfig
4157         check_mount || error "check_mount failed"
4158
4159         $LFS setstripe -c -1 $MOUNT ||
4160                 error "$LFS setstripe -c -1 $MOUNT failed"
4161         $LFS getstripe $MOUNT || error "$LFS getstripe $MOUNT failed"
4162
4163         echo "ok" > $MOUNT/widestripe
4164         $LFS getstripe $MOUNT/widestripe ||
4165                 error "$LFS getstripe $MOUNT/widestripe failed"
4166
4167         # In the future, we may introduce more EAs, such as selinux, enlarged
4168         # LOV EA, and so on. These EA will use some EA space that is shared by
4169         # ACL entries. So here we only check some reasonable ACL entries count,
4170         # instead of the max number that is calculated from the max_ea_size.
4171         if [ "$MDS1_VERSION" -lt $(version_code 2.8.57) ]; then
4172                 count=28        # hard coded of RPC protocol
4173         elif large_xattr_enabled; then
4174                 count=4500      # max_num 8187 max_ea_size = 65452
4175                                 # not create too many (4500) to save test time
4176         else
4177                 count=450       # max_num 497 max_ea_size = 4012
4178         fi
4179
4180         echo "It is expected to hold at least $count ACL entries"
4181         trap cleanup_48 EXIT ERR
4182         for ((i = 0; i < $count; i++)) do
4183                 setfacl -m u:$((i + 100)):rw $MOUNT/widestripe ||
4184                         error "Fail to setfacl for $MOUNT/widestripe at $i"
4185         done
4186
4187         cancel_lru_locks mdc
4188         stat $MOUNT/widestripe || error "stat $MOUNT/widestripe failed"
4189         local r_count=$(getfacl $MOUNT/widestripe | grep "user:" | wc -l)
4190
4191         count=$((count + 1)) # for the entry "user::rw-"
4192
4193         [ $count -eq $r_count ] ||
4194                 error "Expected ACL entries $count, but got $r_count"
4195
4196         cleanup_48
4197 }
4198 run_test 48 "too many acls on file"
4199
4200 # check PARAM_SYS_LDLM_TIMEOUT option of MKFS.LUSTRE
4201 test_49a() { # bug 17710
4202         local timeout_orig=$TIMEOUT
4203         local ldlm_timeout_orig=$LDLM_TIMEOUT
4204         local LOCAL_TIMEOUT=20
4205
4206         LDLM_TIMEOUT=$LOCAL_TIMEOUT
4207         TIMEOUT=$LOCAL_TIMEOUT
4208
4209         reformat
4210         setup_noconfig
4211         check_mount || error "client mount failed"
4212
4213         echo "check ldlm_timout..."
4214         local LDLM_MDS="$(do_facet $SINGLEMDS $LCTL get_param -n ldlm_timeout)"
4215         local LDLM_OST1="$(do_facet ost1 $LCTL get_param -n ldlm_timeout)"
4216         local LDLM_CLIENT="$(do_facet client $LCTL get_param -n ldlm_timeout)"
4217
4218         if [ $LDLM_MDS -ne $LDLM_OST1 -o $LDLM_MDS -ne $LDLM_CLIENT ]; then
4219                 error "Different LDLM_TIMEOUT:$LDLM_MDS $LDLM_OST1 $LDLM_CLIENT"
4220         fi
4221
4222         if [ $LDLM_MDS -ne $((LOCAL_TIMEOUT / 3)) ]; then
4223                 error "LDLM_TIMEOUT($LDLM_MDS) is not $((LOCAL_TIMEOUT / 3))"
4224         fi
4225
4226         umount_client $MOUNT || error "umount_client $MOUNT failed"
4227         stop_ost || error "problem stopping OSS"
4228         stop_mds || error "problem stopping MDS"
4229
4230         LDLM_TIMEOUT=$ldlm_timeout_orig
4231         TIMEOUT=$timeout_orig
4232 }
4233 run_test 49a "check PARAM_SYS_LDLM_TIMEOUT option of mkfs.lustre"
4234
4235 test_49b() { # bug 17710
4236         local timeout_orig=$TIMEOUT
4237         local ldlm_timeout_orig=$LDLM_TIMEOUT
4238         local LOCAL_TIMEOUT=20
4239
4240         LDLM_TIMEOUT=$((LOCAL_TIMEOUT - 1))
4241         TIMEOUT=$LOCAL_TIMEOUT
4242
4243         reformat
4244         setup_noconfig
4245         check_mount || error "client mount failed"
4246
4247         local LDLM_MDS="$(do_facet $SINGLEMDS $LCTL get_param -n ldlm_timeout)"
4248         local LDLM_OST1="$(do_facet ost1 $LCTL get_param -n ldlm_timeout)"
4249         local LDLM_CLIENT="$(do_facet client $LCTL get_param -n ldlm_timeout)"
4250
4251         if [ $LDLM_MDS -ne $LDLM_OST1 -o $LDLM_MDS -ne $LDLM_CLIENT ]; then
4252                 error "Different LDLM_TIMEOUT:$LDLM_MDS $LDLM_OST1 $LDLM_CLIENT"
4253         fi
4254
4255         if [ $LDLM_MDS -ne $((LOCAL_TIMEOUT - 1)) ]; then
4256                 error "LDLM_TIMEOUT($LDLM_MDS) is not $((LOCAL_TIMEOUT - 1))"
4257         fi
4258
4259         cleanup || error "cleanup failed"
4260
4261         LDLM_TIMEOUT=$ldlm_timeout_orig
4262         TIMEOUT=$timeout_orig
4263 }
4264 run_test 49b "check PARAM_SYS_LDLM_TIMEOUT option of mkfs.lustre"
4265
4266 lazystatfs() {
4267         # wait long enough to exceed OBD_STATFS_CACHE_SECONDS = 1
4268         sleep 2
4269         # Test both statfs and lfs df and fail if either one fails
4270         multiop_bg_pause $1 f_
4271         RC=$?
4272         PID=$!
4273         killall -USR1 multiop
4274         [ $RC -ne 0 ] && log "lazystatfs multiop failed"
4275         wait $PID || { RC=$?; log "multiop return error "; }
4276
4277         # wait long enough to exceed OBD_STATFS_CACHE_SECONDS = 1
4278         sleep 2
4279         $LFS df -l &
4280         PID=$!
4281         sleep 5
4282         if kill -s 0 $PID; then
4283                 RC=1
4284                 kill -s 9 $PID
4285                 log "lazystatfs lfs df failed to complete in 5s"
4286         fi
4287
4288         return $RC
4289 }
4290
4291 test_50a() {
4292         setup
4293         $LCTL set_param llite.$FSNAME-*.lazystatfs=1
4294         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
4295
4296         lazystatfs $MOUNT || error "lazystatfs failed but no down servers"
4297
4298         cleanup || error "cleanup failed with rc $?"
4299 }
4300 run_test 50a "lazystatfs all servers available"
4301
4302 test_50b() {
4303         setup
4304         $LCTL set_param llite.$FSNAME-*.lazystatfs=1
4305         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
4306
4307         # Wait for client to detect down OST
4308         stop_ost || error "Unable to stop OST1"
4309         wait_osc_import_state client ost DISCONN
4310         $LCTL dl
4311         log "OSCs should all be DISCONN"
4312
4313         lazystatfs $MOUNT || error "lazystatfs should not return EIO"
4314
4315         umount_client $MOUNT || error "Unable to unmount client"
4316         stop_mds || error "Unable to stop MDS"
4317 }
4318 run_test 50b "lazystatfs all servers down"
4319
4320 test_50c() {
4321         start_mds || error "Unable to start MDS"
4322         start_ost || error "Unable to start OST1"
4323         start_ost2 || error "Unable to start OST2"
4324         mount_client $MOUNT || error "Unable to mount client"
4325         $LCTL set_param llite.$FSNAME-*.lazystatfs=1
4326         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
4327
4328         # Wait for client to detect down OST
4329         stop_ost || error "Unable to stop OST1"
4330         wait_osc_import_state mds ost DISCONN
4331         lazystatfs $MOUNT || error "lazystatfs failed with one down server"
4332
4333         umount_client $MOUNT || error "Unable to unmount client"
4334         stop_ost2 || error "Unable to stop OST2"
4335         stop_mds || error "Unable to stop MDS"
4336         #writeconf to remove all ost2 traces for subsequent tests
4337         writeconf_or_reformat
4338 }
4339 run_test 50c "lazystatfs one server down"
4340
4341 test_50d() {
4342         start_mds || error "Unable to start MDS"
4343         start_ost || error "Unable to start OST1"
4344         start_ost2 || error "Unable to start OST2"
4345         mount_client $MOUNT || error "Unable to mount client"
4346         $LCTL set_param llite.$FSNAME-*.lazystatfs=1
4347         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
4348
4349         # Issue the statfs during the window where the client still
4350         # belives the OST to be available but it is in fact down.
4351         # No failure just a statfs which hangs for a timeout interval.
4352         stop_ost || error "Unable to stop OST1"
4353         lazystatfs $MOUNT || error "lazystatfs failed with one down server"
4354
4355         umount_client $MOUNT || error "Unable to unmount client"
4356         stop_ost2 || error "Unable to stop OST2"
4357         stop_mds || error "Unable to stop MDS"
4358         #writeconf to remove all ost2 traces for subsequent tests
4359         writeconf_or_reformat
4360 }
4361 run_test 50d "lazystatfs client/server conn race"
4362
4363 test_50e() {
4364         local RC1
4365         local pid
4366
4367         reformat_and_config
4368         start_mds || error "Unable to start MDS"
4369         #first client should see only one ost
4370         start_ost || error "Unable to start OST1"
4371         wait_osc_import_state mds ost FULL
4372
4373         # Wait for client to detect down OST
4374         stop_ost || error "Unable to stop OST1"
4375         wait_osc_import_state mds ost DISCONN
4376
4377         mount_client $MOUNT || error "Unable to mount client"
4378         $LCTL set_param llite.$FSNAME-*.lazystatfs=0
4379
4380         multiop_bg_pause $MOUNT _f
4381         RC1=$?
4382         pid=$!
4383
4384         if [ $RC1 -ne 0 ]; then
4385                 log "multiop failed $RC1"
4386         else
4387             kill -USR1 $pid
4388             sleep $(( $TIMEOUT+1 ))
4389             kill -0 $pid
4390             [ $? -ne 0 ] && error "process isn't sleep"
4391             start_ost || error "Unable to start OST1"
4392             wait $pid || error "statfs failed"
4393         fi
4394
4395         umount_client $MOUNT || error "Unable to unmount client"
4396         stop_ost || error "Unable to stop OST1"
4397         stop_mds || error "Unable to stop MDS"
4398 }
4399 run_test 50e "normal statfs all servers down"
4400
4401 test_50f() {
4402         local RC1
4403         local pid
4404         CONN_PROC="osc.$FSNAME-OST0001-osc-[M]*.ost_server_uuid"
4405
4406         start_mds || error "Unable to start mds"
4407         #first client should see only one ost
4408         start_ost || error "Unable to start OST1"
4409         wait_osc_import_state mds ost FULL
4410
4411         start_ost2 || error "Unable to start OST2"
4412         wait_osc_import_state mds ost2 FULL
4413
4414         # Wait for client to detect down OST
4415         stop_ost2 || error "Unable to stop OST2"
4416
4417         wait_osc_import_state mds ost2 DISCONN
4418         mount_client $MOUNT || error "Unable to mount client"
4419         $LCTL set_param llite.$FSNAME-*.lazystatfs=0
4420
4421         multiop_bg_pause $MOUNT _f
4422         RC1=$?
4423         pid=$!
4424
4425         if [ $RC1 -ne 0 ]; then
4426                 log "lazystatfs multiop failed $RC1"
4427         else
4428             kill -USR1 $pid
4429             sleep $(( $TIMEOUT+1 ))
4430             kill -0 $pid
4431             [ $? -ne 0 ] && error "process isn't sleep"
4432             start_ost2 || error "Unable to start OST2"
4433             wait $pid || error "statfs failed"
4434             stop_ost2 || error "Unable to stop OST2"
4435         fi
4436
4437         umount_client $MOUNT -f || error "Unable to unmount client"
4438         stop_ost || error "Unable to stop OST1"
4439         stop_mds || error "Unable to stop MDS"
4440         #writeconf to remove all ost2 traces for subsequent tests
4441         writeconf_or_reformat
4442 }
4443 run_test 50f "normal statfs one server in down"
4444
4445 test_50g() {
4446         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >=2 OSTs"
4447         setup
4448         start_ost2 || error "Unable to start OST2"
4449         wait_osc_import_state mds ost2 FULL
4450         wait_osc_import_ready client ost2
4451
4452         if [[ $PERM_CMD == *"set_param -P"* ]]; then
4453                 local PARAM="osc.${FSNAME}-OST0001*.active"
4454         else
4455                 local PARAM="${FSNAME}-OST0001.osc.active"
4456         fi
4457
4458         $LFS setstripe -c -1 $DIR/$tfile || error "$LFS setstripe failed"
4459         do_facet mgs $PERM_CMD $PARAM=0 || error "Unable to deactivate OST"
4460
4461         umount_client $MOUNT || error "Unable to unmount client"
4462         mount_client $MOUNT || error "Unable to mount client"
4463         # This df should not cause a panic
4464         df -k $MOUNT
4465
4466         do_facet mgs $PERM_CMD $PARAM=1 || error "Unable to activate OST"
4467         rm -f $DIR/$tfile || error "unable to remove file $DIR/$tfile"
4468         umount_client $MOUNT || error "Unable to unmount client"
4469         stop_ost2 || error "Unable to stop OST2"
4470         stop_ost || error "Unable to stop OST1"
4471         stop_mds || error "Unable to stop MDS"
4472         #writeconf to remove all ost2 traces for subsequent tests
4473         writeconf_or_reformat
4474 }
4475 run_test 50g "deactivated OST should not cause panic"
4476
4477 # LU-642
4478 test_50h() {
4479         # prepare MDT/OST, make OSC inactive for OST1
4480         [ "$OSTCOUNT" -lt "2" ] && skip_env "needs >=2 OSTs"
4481
4482         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
4483         do_facet ost1 "$TUNEFS --param osc.active=0 `ostdevname 1`" ||
4484                 error "tunefs OST1 failed"
4485         start_mds  || error "Unable to start MDT"
4486         start_ost  || error "Unable to start OST1"
4487         start_ost2 || error "Unable to start OST2"
4488         mount_client $MOUNT || error "client start failed"
4489
4490         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
4491
4492         # activatate OSC for OST1
4493         set_persistent_param_and_check client            \
4494                 "osc.${FSNAME}-OST0000-osc-[!M]*.active" \
4495                 "${FSNAME}-OST0000.osc.active" 1
4496
4497         mkdir $DIR/$tdir/2 || error "mkdir $DIR/$tdir/2 failed"
4498         $LFS setstripe -c -1 -i 0 $DIR/$tdir/2 ||
4499                 error "$LFS setstripe $DIR/$tdir/2 failed"
4500         sleep 1 && echo "create a file after OST1 is activated"
4501         # doing some io, shouldn't crash
4502         dd if=/dev/zero of=$DIR/$tdir/2/$tfile-io bs=1M count=10
4503
4504         # check OSC import is working
4505         stat $DIR/$tdir/2/* >/dev/null 2>&1 ||
4506                 error "some OSC imports are still not connected"
4507
4508         # cleanup
4509         rm -rf $DIR/$tdir
4510         umount_client $MOUNT || error "Unable to umount client"
4511         stop_ost2 || error "Unable to stop OST2"
4512         cleanup_nocli || error "cleanup_nocli failed with $?"
4513 }
4514 run_test 50h "LU-642: activate deactivated OST"
4515
4516 test_50i() {
4517         # prepare MDT/OST, make OSC inactive for OST1
4518         [ "$MDSCOUNT" -lt "2" ] && skip "needs >= 2 MDTs"
4519
4520         load_modules
4521         [ $(facet_fstype mds2) == zfs ] && import_zpool mds2
4522         do_facet mds2 "$TUNEFS --param mdc.active=0 $(mdsdevname 2)" ||
4523                 error "tunefs MDT2 failed"
4524         start_mds  || error "Unable to start MDT"
4525         start_ost  || error "Unable to start OST1"
4526         start_ost2 || error "Unable to start OST2"
4527         mount_client $MOUNT || error "client start failed"
4528
4529         mkdir_on_mdt0 $DIR/$tdir || error "mkdir $DIR/$tdir failed"
4530
4531         if [[ $PERM_CMD == *"set_param -P"* ]]; then
4532                 $PERM_CMD mdc.${FSNAME}-MDT0001-mdc-*.active=0 &&
4533                         error "deactive MDC0 succeeds"
4534         else
4535                 $PERM_CMD ${FSNAME}-MDT0000.mdc.active=0 &&
4536                         error "deactive MDC0 succeeds"
4537         fi
4538
4539         # activate MDC for MDT2
4540         set_persistent_param_and_check client            \
4541                 "mdc.${FSNAME}-MDT0001-mdc-*.active" \
4542                 "${FSNAME}-MDT0001.mdc.active" 1
4543
4544         wait_clients_import_state ${CLIENTS:-$HOSTNAME} mds2 FULL
4545         if [ "$MDS1_VERSION" -ge $(version_code 2.7.60) ]
4546         then
4547                 wait_dne_interconnect
4548         fi
4549         $LFS mkdir -i1 $DIR/$tdir/2 || error "mkdir $DIR/$tdir/2 failed"
4550         # create some file
4551         createmany -o $DIR/$tdir/2/$tfile-%d 1 || error "create files failed"
4552
4553         rm -rf $DIR/$tdir/2 || error "unlink dir failed"
4554
4555         # deactivate MDC for MDT2
4556         set_persistent_param_and_check client           \
4557                 "mdc.${FSNAME}-MDT0001-mdc-*.active"    \
4558                 "${FSNAME}-MDT0001.mdc.active" 0
4559
4560         wait_osp_active mds ${FSNAME}-MDT0001 1 0
4561
4562         $LFS mkdir -i1 $DIR/$tdir/2 &&
4563                 error "mkdir $DIR/$tdir/2 succeeds after deactive MDT"
4564
4565         $LFS mkdir -i0 -c$MDSCOUNT $DIR/$tdir/striped_dir ||
4566                 error "mkdir $DIR/$tdir/striped_dir fails after deactive MDT2"
4567
4568         local stripe_count=$($LFS getdirstripe -c $DIR/$tdir/striped_dir)
4569         [ $stripe_count -eq $((MDSCOUNT - 1)) ] ||
4570                 error "wrong $stripe_count != $((MDSCOUNT -1)) for striped_dir"
4571
4572         # cleanup
4573         umount_client $MOUNT || error "Unable to umount client"
4574         stop_mds
4575         stop_ost
4576         stop_ost 2
4577 }
4578 run_test 50i "activate deactivated MDT"
4579
4580 test_51() {
4581         local LOCAL_TIMEOUT=20
4582
4583         reformat
4584         setup_noconfig
4585         check_mount || error "check_mount failed"
4586
4587         mkdir $MOUNT/$tdir || error "mkdir $MOUNT/$tdir failed"
4588         $LFS setstripe -c -1 $MOUNT/$tdir ||
4589                 error "$LFS setstripe -c -1 $MOUNT/$tdir failed"
4590         #define OBD_FAIL_MDS_REINT_DELAY         0x142
4591         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0x142"
4592         touch $MOUNT/$tdir/$tfile &
4593         local pid=$!
4594         sleep 2
4595         start_ost2 || error "Unable to start OST1"
4596         wait $pid
4597         stop_ost2 || error "Unable to stop OST1"
4598         umount_client $MOUNT -f || error "unmount $MOUNT failed"
4599         cleanup_nocli || error "stop server failed"
4600         #writeconf to remove all ost2 traces for subsequent tests
4601         writeconf_or_reformat
4602 }
4603 run_test 51 "Verify that mdt_reint handles RMF_MDT_MD correctly when an OST is added"
4604
4605 copy_files_xattrs()
4606 {
4607         local node=$1
4608         local dest=$2
4609         local xattrs=$3
4610         shift 3
4611
4612         do_node $node mkdir -p $dest
4613         [ $? -eq 0 ] || { error "Unable to create directory"; return 1; }
4614
4615         do_node $node  'tar cf - '$*' | tar xf - -C '$dest';
4616                         [ \"\${PIPESTATUS[*]}\" = \"0 0\" ] || exit 1'
4617         [ $? -eq 0 ] || { error "Unable to tar files"; return 2; }
4618
4619         do_node $node 'getfattr -d -m "[a-z]*\\." '$*' > '$xattrs
4620         [ $? -eq 0 ] || { error "Unable to read xattrs"; return 3; }
4621 }
4622
4623 diff_files_xattrs()
4624 {
4625         local node=$1
4626         local backup=$2
4627         local xattrs=$3
4628         shift 3
4629
4630         local backup2=${TMP}/backup2
4631
4632         do_node $node mkdir -p $backup2
4633         [ $? -eq 0 ] || { error "Unable to create directory"; return 1; }
4634
4635         do_node $node  'tar cf - '$*' | tar xf - -C '$backup2';
4636                         [ \"\${PIPESTATUS[*]}\" = \"0 0\" ] || exit 1'
4637         [ $? -eq 0 ] || { error "Unable to tar files to diff"; return 2; }
4638
4639         do_node $node "diff -rq $backup $backup2"
4640         [ $? -eq 0 ] || { error "contents differ"; return 3; }
4641
4642         local xattrs2=${TMP}/xattrs2
4643         do_node $node 'getfattr -d -m "[a-z]*\\." '$*' > '$xattrs2
4644         [ $? -eq 0 ] || { error "Unable to read xattrs to diff"; return 4; }
4645
4646         do_node $node "diff $xattrs $xattrs2"
4647         [ $? -eq 0 ] || { error "xattrs differ"; return 5; }
4648
4649         do_node $node "rm -rf $backup2 $xattrs2"
4650         [ $? -eq 0 ] || { error "Unable to delete temporary files"; return 6; }
4651 }
4652
4653 test_52() {
4654         if [ "$mds1_FSTYPE" != ldiskfs ]; then
4655                 skip "ldiskfs only test"
4656         fi
4657
4658         start_mds || error "Unable to start MDS"
4659         start_ost || error "Unable to start OST1"
4660         mount_client $MOUNT || error "Unable to mount client"
4661
4662         local nrfiles=8
4663         local ost1mnt=$(facet_mntpt ost1)
4664         local ost1node=$(facet_active_host ost1)
4665         local ost1tmp=$TMP/conf52
4666         local loop
4667
4668         mkdir $DIR/$tdir || error "Unable to create $DIR/$tdir"
4669         touch $TMP/modified_first || error "Unable to create temporary file"
4670         local mtime=$(stat -c %Y $TMP/modified_first)
4671         do_node $ost1node "mkdir -p $ost1tmp &&
4672                            touch -m -d @$mtime $ost1tmp/modified_first" ||
4673                 error "Unable to create temporary file"
4674         sleep 1
4675
4676         $LFS setstripe -c -1 -S 1M $DIR/$tdir || error "$LFS setstripe failed"
4677
4678         for (( i=0; i < nrfiles; i++ )); do
4679                 multiop $DIR/$tdir/$tfile-$i Ow1048576w1048576w524288c ||
4680                         error "multiop failed"
4681                 echo -n .
4682         done
4683         echo
4684
4685         # sync all the data and make sure no pending data on the client,
4686         # thus the SOM xattr would not be changed any more.
4687         cancel_lru_locks osc
4688
4689         # backup files
4690         echo backup files to $TMP/$tdir
4691         local files=$(find $DIR/$tdir -type f -newer $TMP/modified_first)
4692         copy_files_xattrs $(hostname) $TMP/$tdir $TMP/file_xattrs $files ||
4693                 error "Unable to copy files"
4694
4695         umount_client $MOUNT || error "Unable to umount client"
4696         stop_ost || error "Unable to stop ost1"
4697
4698         echo mount ost1 as ldiskfs
4699         do_node $ost1node mkdir -p $ost1mnt || error "Unable to create $ost1mnt"
4700         if ! do_node $ost1node test -b $ost1_dev; then
4701                 loop="-o loop"
4702         fi
4703         do_node $ost1node mount -t "$ost1_FSTYPE" $loop $ost1_dev \
4704                 $ost1mnt ||
4705                 error "Unable to mount ost1 as ldiskfs"
4706
4707         # backup objects
4708         echo backup objects to $ost1tmp/objects
4709         local objects=$(do_node $ost1node 'find '$ost1mnt'/O/[0-9]* -type f'\
4710                 '-size +0 -newer '$ost1tmp'/modified_first -regex ".*\/[0-9]+"')
4711         copy_files_xattrs $ost1node $ost1tmp/objects $ost1tmp/object_xattrs \
4712                         $objects ||
4713                 error "Unable to copy objects"
4714
4715         # move objects to lost+found
4716         do_node $ost1node 'mv '$objects' '${ost1mnt}'/lost+found'
4717         [ $? -eq 0 ] || { error "Unable to move objects"; return 14; }
4718
4719         do_node $ost1node "umount $ost1mnt" ||
4720                 error "Unable to umount ost1 as ldiskfs"
4721
4722         start_ost || error "Unable to start OST1"
4723         mount_client $MOUNT || error "Unable to mount client"
4724
4725         local REPAIRED=$(do_node $ost1node "$LCTL get_param \
4726                          -n osd-ldiskfs.$FSNAME-OST0000.oi_scrub" |
4727                          awk '/^lf_repa[ri]*ed/ { print $2 }')
4728         [ $REPAIRED -gt 0 ] ||
4729                 error "Some entry under /lost+found should be repaired"
4730
4731         # compare files
4732         diff_files_xattrs $(hostname) $TMP/$tdir $TMP/file_xattrs $files ||
4733                 error "Unable to diff files"
4734
4735         rm -rf $TMP/$tdir $TMP/file_xattrs ||
4736                 error "Unable to delete temporary files"
4737         do_node $ost1node "rm -rf $ost1tmp" ||
4738                 error "Unable to delete temporary files"
4739         cleanup || error "cleanup failed with $?"
4740 }
4741 run_test 52 "check recovering objects from lost+found"
4742
4743 # Checks threads_min/max/started for some service
4744 #
4745 # Arguments: service name (OST or MDT), facet (e.g., ost1, $SINGLEMDS), and a
4746 # parameter pattern prefix like 'ost.*.ost'.
4747 thread_sanity() {
4748         local modname=$1
4749         local facet=$2
4750         local parampat=$3
4751         local opts=$4
4752         local basethr=$5
4753         local tmin
4754         local tmin2
4755         local tmax
4756         local tmax2
4757         local tstarted
4758         local paramp
4759         local msg="Insane $modname thread counts"
4760         local ncpts=$(check_cpt_number $facet)
4761         local nthrs
4762         shift 4
4763
4764         check_mount || return 41
4765
4766         # We need to expand $parampat, but it may match multiple parameters, so
4767         # we'll pick the first one
4768         if ! paramp=$(do_facet $facet "lctl get_param -N ${parampat}.threads_min"|head -1); then
4769                 error "Couldn't expand ${parampat}.threads_min parameter name"
4770                 return 22
4771         fi
4772
4773         # Remove the .threads_min part
4774         paramp=${paramp%.threads_min}
4775
4776         # Check for sanity in defaults
4777         tmin=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4778                echo 0)
4779         tmax=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_max" ||
4780                echo 0)
4781         tstarted=$(do_facet $facet "$LCTL get_param \
4782                                     -n ${paramp}.threads_started" || echo 0)
4783         lassert 23 "$msg (PDSH problems?)" '(($tstarted && $tmin && $tmax))' ||
4784                 return $?
4785         lassert 24 "$msg" '(($tstarted >= $tmin && $tstarted <= $tmax ))' ||
4786                 return $?
4787         nthrs=$(expr $tmax - $tmin)
4788         if [ $nthrs -lt $ncpts ]; then
4789                 nthrs=0
4790         else
4791                 nthrs=$ncpts
4792         fi
4793
4794         [ $tmin -eq $tmax -a $tmin -eq $tstarted ] &&
4795                 skip_env "module parameter forced $facet thread count"
4796
4797         # Check that we can change min/max
4798         do_facet $facet "$LCTL set_param \
4799                          ${paramp}.threads_min=$((tmin + nthrs))"
4800         do_facet $facet "$LCTL set_param \
4801                          ${paramp}.threads_max=$((tmax - nthrs))"
4802         tmin2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4803                 echo 0)
4804         tmax2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_max" ||
4805                 echo 0)
4806         lassert 25 "$msg" '(($tmin2 == ($tmin + $nthrs) &&
4807                             $tmax2 == ($tmax - $nthrs)))' || return $?
4808
4809         # Check that we can set min/max to the same value
4810         tmin=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4811                echo 0)
4812         do_facet $facet "$LCTL set_param ${paramp}.threads_max=$tmin"
4813         tmin2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4814                 echo 0)
4815         tmax2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_max" ||
4816                 echo 0)
4817         lassert 26 "$msg" '(($tmin2 == $tmin && $tmax2 == $tmin))' || return $?
4818
4819         # Check that we can't set max < min
4820         do_facet $facet "$LCTL set_param ${paramp}.threads_max=$((tmin - 1))"
4821         tmin2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4822                 echo 0)
4823         tmax2=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_max" ||
4824                 echo 0)
4825         lassert 27 "$msg" '(($tmin2 <= $tmax2))' || return $?
4826
4827         # We need to ensure that we get the module options desired; to do this
4828         # we set LOAD_MODULES_REMOTE=true and we call setmodopts below.
4829         LOAD_MODULES_REMOTE=true
4830         cleanup
4831         local oldvalue
4832         local newvalue="${opts}=$(expr $basethr \* $ncpts)"
4833
4834         setmodopts -a $modname "$newvalue" oldvalue
4835
4836         setup
4837         check_mount || return 41
4838
4839         # Restore previous setting of MODOPTS_*
4840         setmodopts $modname "$oldvalue"
4841
4842         (( $MDS1_VERSION > $(version_code 2.12.52.91) )) || {
4843                 echo "skip interop for MDS < v2_12_52-91-g183cb1e3cdd2"
4844                 return 0
4845         }
4846
4847         # Check that $opts took
4848         tmin=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_min" ||
4849                 echo 0)
4850         tmax=$(do_facet $facet "$LCTL get_param -n ${paramp}.threads_max" ||
4851                 echo 0)
4852         tstarted=$(do_facet $facet \
4853                    "$LCTL get_param -n ${paramp}.threads_started" || echo 0)
4854         lassert 28 "$msg" '(($tstarted >= $tmin && $tstarted <= $tmax ))' ||
4855                 return $?
4856 }
4857
4858 test_53a() {
4859         setup
4860         thread_sanity OST ost1 'ost.*.ost' 'oss_num_threads' '16'
4861         cleanup || error "cleanup failed with rc $?"
4862 }
4863 run_test 53a "check OSS thread count params"
4864
4865 test_53b() {
4866         setup
4867         thread_sanity MDT $SINGLEMDS 'mds.*.*.' 'mds_num_threads' 16
4868         cleanup || error "cleanup failed with $?"
4869 }
4870 run_test 53b "check MDS thread count params"
4871
4872 test_54a() {
4873         if [ "$mds1_FSTYPE" != ldiskfs ]; then
4874                 skip "ldiskfs only test"
4875         fi
4876
4877         do_rpc_nodes $(facet_host ost1) run_llverdev $(ostdevname 1) -p ||
4878                 error "llverdev failed with rc=$?"
4879         reformat_and_config
4880 }
4881 run_test 54a "test llverdev and partial verify of device"
4882
4883 test_54b() {
4884         if [ "$mds1_FSTYPE" != ldiskfs ]; then
4885                 skip "ldiskfs only test"
4886         fi
4887
4888         setup
4889         run_llverfs $MOUNT -p || error "llverfs failed with rc=$?"
4890         cleanup || error "cleanup failed with rc=$?"
4891 }
4892 run_test 54b "test llverfs and partial verify of filesystem"
4893
4894 lov_objid_size()
4895 {
4896         local max_ost_index=$1
4897
4898         echo -n $(((max_ost_index + 1) * 8))
4899 }
4900
4901 test_55() {
4902         if [ "$mds1_FSTYPE" != ldiskfs ]; then
4903                 skip "ldiskfs only test"
4904         fi
4905
4906         local mdsdev=$(mdsdevname 1)
4907         local mdsvdev=$(mdsvdevname 1)
4908
4909         for i in 1023 2048
4910         do
4911                 if ! combined_mgs_mds; then
4912                         stop_mgs || error "stopping MGS service failed"
4913                         format_mgs || error "formatting MGT failed"
4914                 fi
4915                 add mds1 $(mkfs_opts mds1 ${mdsdev}) --reformat $mdsdev \
4916                         $mdsvdev || exit 10
4917                 add ost1 $(mkfs_opts ost1 $(ostdevname 1)) --index=$i \
4918                         --reformat $(ostdevname 1) $(ostvdevname 1)
4919                 setup_noconfig
4920                 stopall
4921                 setup_noconfig
4922                 sync
4923
4924                 echo checking size of lov_objid for ost index $i
4925                 LOV_OBJID_SIZE=$(do_facet mds1 "$DEBUGFS -R 'stat lov_objid' $mdsdev 2>/dev/null" |
4926                                  grep ^User | awk -F 'Size: ' '{print $2}')
4927                 if [ "$LOV_OBJID_SIZE" != $(lov_objid_size $i) ]; then
4928                         error "lov_objid size has to be $(lov_objid_size $i), not $LOV_OBJID_SIZE"
4929                 else
4930                         echo ok, lov_objid size is correct: $LOV_OBJID_SIZE
4931                 fi
4932                 stopall
4933         done
4934
4935         reformat_and_config
4936 }
4937 run_test 55 "check lov_objid size"
4938
4939 test_56a() {
4940         local mds_journal_size_orig=$MDSJOURNALSIZE
4941         local n
4942
4943         MDSJOURNALSIZE=16
4944
4945         formatall
4946         add ost1 $(mkfs_opts ost1 $(ostdevname 1)) --index=10000 --reformat \
4947                 $(ostdevname 1) $(ostvdevname 1)
4948         add ost2 $(mkfs_opts ost2 $(ostdevname 2)) --index=1000 --reformat \
4949                 $(ostdevname 2) $(ostvdevname 2)
4950
4951         start_mgsmds
4952         start_ost || error "Unable to start first ost (idx 10000)"
4953         start_ost2 || error "Unable to start second ost (idx 1000)"
4954         mount_client $MOUNT || error "Unable to mount client"
4955         echo ok
4956         $LFS osts
4957
4958         # test instantiating PFL components with sparse index LU-15513
4959         mkdir -p $MOUNT/$tdir
4960         $LFS setstripe -E 4M -c 1 -E 1G -c 4 -S4M -E eof -c -1 $MOUNT/$tdir
4961         dd if=/dev/zero of=$MOUNT/$tdir/$tfile bs=4K count=1 seek=10k ||
4962                 error "dd to second component failed"
4963
4964         if [[ "$MDS1_VERSION" -ge $(version_code 2.6.54) ]] ||
4965            [[ "$MDS1_VERSION" -ge $(version_code 2.5.4) &&
4966               "$MDS1_VERSION" -lt $(version_code 2.5.11) ]]; then
4967                 wait_osc_import_state mds ost1 FULL
4968                 wait_osc_import_state mds ost2 FULL
4969                 $LFS setstripe --stripe-count=-1 $DIR/$tfile ||
4970                         error "Unable to setstripe $DIR/$tfile"
4971                 n=$($LFS getstripe --stripe-count $DIR/$tfile)
4972                 [ "$n" -eq 2 ] || error "Stripe count not two: $n"
4973                 rm $DIR/$tfile
4974         fi
4975
4976         stopall
4977         MDSJOURNALSIZE=$mds_journal_size_orig
4978         reformat_and_config
4979 }
4980 run_test 56a "check big OST indexes and out-of-index-order start"
4981
4982 cleanup_56b() {
4983         trap 0
4984
4985         umount_client $MOUNT -f || error "unmount client failed"
4986         stop mds1
4987         stop mds2
4988         stop mds3
4989         stopall
4990         reformat_and_config
4991 }
4992
4993 test_56b() {
4994         [ $MDSCOUNT -lt 3 ] && skip "needs >= 3 MDTs"
4995
4996         trap cleanup_56b EXIT RETURN ERR
4997         stopall
4998
4999         if ! combined_mgs_mds ; then
5000                 format_mgs
5001                 start_mgs
5002         fi
5003
5004         add mds1 $(mkfs_opts mds1 $(mdsdevname 1)) --index=0 --reformat \
5005                 $(mdsdevname 1) $(mdsvdevname 1)
5006         add mds2 $(mkfs_opts mds2 $(mdsdevname 2)) --index=1 --reformat \
5007                 $(mdsdevname 2) $(mdsvdevname 2)
5008         add mds3 $(mkfs_opts mds3 $(mdsdevname 3)) --index=1000 --reformat \
5009                 $(mdsdevname 3) $(mdsvdevname 3)
5010         format_ost 1
5011         format_ost 2
5012
5013         start_mdt 1 || error "MDT 1 (idx 0) start failed"
5014         start_mdt 2 || error "MDT 2 (idx 1) start failed"
5015         start_mdt 3 || error "MDT 3 (idx 1000) start failed"
5016         start_ost || error "Unable to start first ost"
5017         start_ost2 || error "Unable to start second ost"
5018
5019         do_nodes $(comma_list $(mdts_nodes)) \
5020                 "$LCTL set_param mdt.*.enable_remote_dir=1 \
5021                 mdt.*.enable_remote_dir_gid=-1"
5022
5023         mount_client $MOUNT || error "Unable to mount client"
5024
5025         $LFS mkdir -c3 $MOUNT/$tdir || error "failed to make testdir"
5026
5027         echo "This is test file 1!" > $MOUNT/$tdir/$tfile.1 ||
5028                 error "failed to make test file 1"
5029         echo "This is test file 2!" > $MOUNT/$tdir/$tfile.2 ||
5030                 error "failed to make test file 2"
5031         echo "This is test file 1000!" > $MOUNT/$tdir/$tfile.1000 ||
5032                 error "failed to make test file 1000"
5033
5034         rm -rf $MOUNT/$tdir || error "failed to remove testdir"
5035
5036         $LFS mkdir -i1000 $MOUNT/$tdir.1000 ||
5037                 error "create remote dir at idx 1000 failed"
5038
5039         output=$($LFS df)
5040         echo "=== START lfs df OUTPUT ==="
5041         echo -e "$output"
5042         echo "==== END lfs df OUTPUT ===="
5043
5044         mdtcnt=$(echo -e "$output" | grep $FSNAME-MDT | wc -l)
5045         ostcnt=$(echo -e "$output" | grep $FSNAME-OST | wc -l)
5046
5047         echo "lfs df returned mdt count $mdtcnt and ost count $ostcnt"
5048         [ $mdtcnt -eq 3 ] || error "lfs df returned wrong mdt count"
5049         [ $ostcnt -eq 2 ] || error "lfs df returned wrong ost count"
5050
5051         echo "This is test file 1!" > $MOUNT/$tdir.1000/$tfile.1 ||
5052                 error "failed to make test file 1"
5053         echo "This is test file 2!" > $MOUNT/$tdir.1000/$tfile.2 ||
5054                 error "failed to make test file 2"
5055         echo "This is test file 1000!" > $MOUNT/$tdir.1000/$tfile.1000 ||
5056                 error "failed to make test file 1000"
5057         rm -rf $MOUNT/$tdir.1000 || error "failed to remove remote_dir"
5058
5059         output=$($LFS mdts)
5060         echo "=== START lfs mdts OUTPUT ==="
5061         echo -e "$output"
5062         echo "==== END lfs mdts OUTPUT ===="
5063
5064         echo -e "$output" | grep -v "MDTS:" | awk '{print $1}' |
5065                 sed 's/://g' > $TMP/mdts-actual.txt
5066         sort $TMP/mdts-actual.txt -o $TMP/mdts-actual.txt
5067
5068         echo -e "0\n1\n1000" > $TMP/mdts-expected.txt
5069
5070         diff $TMP/mdts-expected.txt $TMP/mdts-actual.txt
5071         result=$?
5072
5073         rm $TMP/mdts-expected.txt $TMP/mdts-actual.txt
5074
5075         [ $result -eq 0 ] || error "target_obd proc file is incorrect!"
5076 }
5077 run_test 56b "test target_obd correctness with nonconsecutive MDTs"
5078
5079 test_57a() { # bug 22656
5080         do_rpc_nodes $(facet_active_host ost1) load_modules_local
5081         local NID=$(do_facet ost1 "$LCTL get_param nis" |
5082                     tail -1 | awk '{print $1}')
5083         writeconf_or_reformat
5084         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
5085         do_facet ost1 "$TUNEFS --failnode=$NID `ostdevname 1`" ||
5086                 error "tunefs failed"
5087         start_mgsmds
5088         start_ost && error "OST registration from failnode should fail"
5089         cleanup
5090 }
5091 run_test 57a "initial registration from failnode should fail (should return errs)"
5092
5093 test_57b() {
5094         do_rpc_nodes $(facet_active_host ost1) load_modules_local
5095         local NID=$(do_facet ost1 "$LCTL get_param nis" |
5096                     tail -1 | awk '{print $1}')
5097         writeconf_or_reformat
5098         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
5099         do_facet ost1 "$TUNEFS --servicenode=$NID `ostdevname 1`" ||
5100                 error "tunefs failed"
5101         start_mgsmds
5102         start_ost || error "OST registration from servicenode should not fail"
5103         cleanup
5104 }
5105 run_test 57b "initial registration from servicenode should not fail"
5106
5107 count_osts() {
5108         do_facet mgs $LCTL get_param mgs.MGS.live.$FSNAME | grep OST | wc -l
5109 }
5110
5111 test_58() { # bug 22658
5112         combined_mgs_mds || stop_mgs || error "stopping MGS service failed"
5113         setup_noconfig
5114         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
5115         createmany -o $DIR/$tdir/$tfile-%d 100
5116         unlinkmany $DIR/$tdir/$tfile-%d 100
5117         stop_mds || error "Unable to stop MDS"
5118
5119         local MNTDIR=$(facet_mntpt $SINGLEMDS)
5120         local devname=$(mdsdevname ${SINGLEMDS//mds/})
5121
5122         # remove all files from the OBJECTS dir
5123         mount_fstype $SINGLEMDS
5124
5125         do_facet $SINGLEMDS "find $MNTDIR/O/1/d* -type f -delete"
5126
5127         unmount_fstype $SINGLEMDS
5128         # restart MDS with missing llog files
5129         start_mds || error "unable to start MDS"
5130         do_facet $SINGLEMDS "$LCTL set_param fail_loc=0"
5131         cleanup
5132 }
5133 run_test 58 "missing llog files must not prevent MDT from mounting"
5134
5135 test_59() {
5136         start_mgsmds >> /dev/null
5137         local C1=$(count_osts)
5138         if [ $C1 -eq 0 ]; then
5139                 start_ost >> /dev/null
5140                 C1=$(count_osts)
5141         fi
5142         stopall
5143         echo "original ost count: $C1 (expect > 0)"
5144         [ $C1 -gt 0 ] || error "No OSTs in $FSNAME log"
5145         start_mgsmds -o writeconf >> /dev/null || error "MDT start failed"
5146         local C2=$(count_osts)
5147         echo "after mdt writeconf count: $C2 (expect 0)"
5148         [ $C2 -gt 0 ] && error "MDT writeconf should erase OST logs"
5149         echo "OST start without writeconf should fail:"
5150         start_ost >> /dev/null &&
5151                 error "OST start without writeconf didn't fail"
5152         echo "OST start with writeconf should succeed:"
5153         start_ost -o writeconf >> /dev/null || error "OST1 start failed"
5154         local C3=$(count_osts)
5155         echo "after ost writeconf count: $C3 (expect 1)"
5156         [ $C3 -eq 1 ] || error "new OST writeconf should add:"
5157         start_ost2 -o writeconf >> /dev/null || error "OST2 start failed"
5158         local C4=$(count_osts)
5159         echo "after ost2 writeconf count: $C4 (expect 2)"
5160         [ $C4 -eq 2 ] || error "OST2 writeconf should add log"
5161         stop_ost2 >> /dev/null
5162         cleanup_nocli >> /dev/null
5163         #writeconf to remove all ost2 traces for subsequent tests
5164         writeconf_or_reformat
5165 }
5166 run_test 59 "writeconf mount option"
5167
5168 test_60a() { # LU-471
5169         if [ "$mds1_FSTYPE" != ldiskfs ]; then
5170                 skip "ldiskfs only test"
5171         fi
5172
5173         local num
5174
5175         for num in $(seq $MDSCOUNT); do
5176                 add mds${num} $(mkfs_opts mds${num} $(mdsdevname $num)) \
5177                         --mkfsoptions='\" -E stride=64 -O ^uninit_bg\"' \
5178                         --reformat $(mdsdevname $num) $(mdsvdevname $num) ||
5179                         exit 10
5180         done
5181
5182         dump=$(do_facet $SINGLEMDS dumpe2fs $(mdsdevname 1))
5183         [ ${PIPESTATUS[0]} -eq 0 ] || error "dumpe2fs $(mdsdevname 1) failed"
5184
5185         # MDT default has dirdata feature
5186         echo $dump | grep dirdata > /dev/null || error "dirdata is not set"
5187         # we disable uninit_bg feature
5188         echo $dump | grep uninit_bg > /dev/null && error "uninit_bg is set"
5189         # we set stride extended options
5190         echo $dump | grep stride > /dev/null || error "stride is not set"
5191         stop_mds
5192         reformat_and_config
5193 }
5194 run_test 60a "check mkfs.lustre --mkfsoptions -E -O options setting"
5195
5196 test_60b() {
5197         [[ "$mds1_FSTYPE" == ldiskfs ]] || skip "ldiskfs only test"
5198
5199         local features=$(do_facet $SINGLEMDS $DUMPE2FS $(mdsdevname 1) |
5200                          grep features)
5201         [ ${PIPESTATUS[0]} -eq 0 ] || error "$DUMPE2FS $(mdsdevname 1) failed"
5202
5203         echo $features
5204         # ea_inode feature should be enabled by default for MDTs
5205         [[ "$features" =~ "ea_inode" ]] || error "ea_inode is not set"
5206         # large_dir feature should be enabled by default for MDTs
5207         [[ "$features" =~ "large_dir" ]] || error "large_dir is not set"
5208 }
5209 run_test 60b "check mkfs.lustre MDT default features"
5210
5211 test_61a() { # LU-80
5212         local lxattr=$(large_xattr_enabled)
5213
5214         (( "$MDS1_VERSION" >= $(version_code 2.1.53) )) ||
5215                 skip "Need MDS version at least 2.1.53 for large_xattr"
5216
5217         if [[ "$mds1_FSTYPE" == ldiskfs ]] && ! large_xattr_enabled; then
5218                 lxattr=true
5219
5220                 for ((num=1; num <= $MDSCOUNT; num++)); do
5221                         do_facet mds${num} $TUNE2FS -O ea_inode \
5222                                 $(mdsdevname $num) ||
5223                                 error "tune2fs on mds $num failed"
5224                 done
5225         fi
5226
5227         setup || error "setting up the filesystem failed"
5228         client_up || error "starting client failed"
5229
5230         local file=$DIR/$tfile
5231         touch $file || error "touch $file failed"
5232
5233         local large_value="$(generate_string $(max_xattr_size))"
5234         local small_value="bar"
5235
5236         local name="trusted.big"
5237         log "save large xattr of $(max_xattr_size) bytes on $name on $file"
5238         setfattr -n $name -v $large_value $file ||
5239                 error "saving $name on $file failed"
5240
5241         local new_value=$(get_xattr_value $name $file)
5242         [[ "$new_value" != "$large_value" ]] &&
5243                 error "$name different after saving"
5244
5245         log "shrink value of $name on $file"
5246         setfattr -n $name -v $small_value $file ||
5247                 error "shrinking value of $name on $file failed"
5248
5249         new_value=$(get_xattr_value $name $file)
5250         [[ "$new_value" != "$small_value" ]] &&
5251                 error "$name different after shrinking"
5252
5253         log "grow value of $name on $file"
5254         setfattr -n $name -v $large_value $file ||
5255                 error "growing value of $name on $file failed"
5256
5257         new_value=$(get_xattr_value $name $file)
5258         [[ "$new_value" != "$large_value" ]] &&
5259                 error "$name different after growing"
5260
5261         log "check value of $name on $file after remounting MDS"
5262         fail $SINGLEMDS
5263         new_value=$(get_xattr_value $name $file)
5264         [[ "$new_value" != "$large_value" ]] &&
5265                 error "$name different after remounting MDS"
5266
5267         log "remove large xattr $name from $file"
5268         setfattr -x $name $file || error "removing $name from $file failed"
5269
5270         if $lxattr && [ "$mds1_FSTYPE" == ldiskfs ]; then
5271                 stopall || error "stopping for e2fsck run"
5272                 for num in $(seq $MDSCOUNT); do
5273                         run_e2fsck $(facet_active_host mds$num) \
5274                                 $(mdsdevname $num) "-y" ||
5275                                 error "e2fsck MDT$num failed"
5276                 done
5277                 setup_noconfig || error "remounting the filesystem failed"
5278         fi
5279
5280         # need to delete this file to avoid problems in other tests
5281         rm -f $file
5282         cleanup || error "stopping systems failed"
5283 }
5284 run_test 61a "large xattr"
5285
5286 test_61b() { # LU-80
5287         local lxattr=$(large_xattr_enabled)
5288
5289         (( $MDS1_VERSION >= $(version_code 2.15.51) )) ||
5290                 skip "Need MDS version at least 2.15.51 for large_xattr fix"
5291
5292         [[ "$mds1_FSTYPE" == "ldiskfs" ]] || skip "ldiskfs specific bug"
5293
5294         if ! large_xattr_enabled; then
5295                 lxattr=true
5296
5297                 for (( num=1; num <= $MDSCOUNT; num++ )); do
5298                         do_facet mds${num} $TUNE2FS -O ea_inode \
5299                                 $(mdsdevname $num) ||
5300                                 error "tune2fs on mds $num failed"
5301                 done
5302         fi
5303
5304         setup || error "setting up the filesystem failed"
5305         client_up || error "starting client failed"
5306
5307         local _file=$MOUNT/panda
5308         local large_value="$(generate_string $(max_xattr_size))"
5309         local name="trusted.big"
5310
5311         touch ${_file} || error "touch ${_file} failed"
5312         setfattr -n $name -v $large_value ${_file} ||
5313                 error "saving $name on $file failed"
5314
5315         MDT_DEV="${FSNAME}-MDT0000"
5316         MDT_DEVNAME=$(mdsdevname ${SINGLEMDS//mds/})
5317
5318         stopall || error "stopping for e2fsck run"
5319
5320
5321         ino=$(do_facet $SINGLEMDS "$DEBUGFS -R 'stat /ROOT/panda' \
5322                 ${MDT_DEVNAME} | grep trusted.big")
5323         ino=$(echo "${ino}" | awk '{print $2;}')
5324         echo "large ea "${ino}
5325
5326         do_facet $SINGLEMDS "$DEBUGFS -w -R \\\"ln $ino /lost+found\\\" \
5327                  ${MDT_DEVNAME}"
5328
5329         setup_noconfig || error "remounting the filesystem failed"
5330
5331         do_facet $SINGLEMDS $LCTL lfsck_start -M ${MDT_DEV} -t namespace || {
5332                 error "can't start lfsck namespace"
5333         }
5334
5335         sleep 5
5336         wait_update_facet $SINGLEMDS "$LCTL get_param -n \
5337                 mdd.${MDT_DEV}.lfsck_namespace |
5338                 awk '/^status/ { print \\\$2 }'" "completed" 32 || {
5339                 error "(2) unexpected status"
5340         }
5341
5342         stopall || error "stopping for e2fsck run"
5343         for num in $(seq $MDSCOUNT); do
5344                 run_e2fsck $(facet_active_host mds$num) \
5345                         $(mdsdevname $num) "-y" ||
5346                         error "e2fsck MDT$num failed"
5347         done
5348         setup_noconfig || error "remounting the filesystem failed"
5349
5350         # need to delete this file to avoid problems in other tests
5351         rm -f $file
5352         cleanup || error "stopping systems failed"
5353 }
5354 run_test 61b "large xattr"
5355
5356 test_62() {
5357         if [ "$mds1_FSTYPE" != ldiskfs ]; then
5358                 skip "ldiskfs only test"
5359         fi
5360         [[ "$MDS1_VERSION" -ge $(version_code 2.2.51) ]] ||
5361                 skip "Need MDS version at least 2.2.51"
5362
5363         # MRP-118
5364         local mdsdev=$(mdsdevname 1)
5365         local ostdev=$(ostdevname 1)
5366
5367         echo "disable journal for mds"
5368         do_facet mds1 $TUNE2FS -O ^has_journal $mdsdev || error "tune2fs failed"
5369         start_mds && error "MDT start should fail"
5370         echo "disable journal for ost"
5371         do_facet ost1 $TUNE2FS -O ^has_journal $ostdev || error "tune2fs failed"
5372         start_ost && error "OST start should fail"
5373         cleanup || error "cleanup failed with rc $?"
5374         reformat_and_config
5375 }
5376 run_test 62 "start with disabled journal"
5377
5378 test_63() {
5379         if [ "$mds1_FSTYPE" != ldiskfs ]; then
5380                 skip "ldiskfs only test"
5381         fi
5382
5383         do_rpc_nodes $(facet_active_host $SINGLEMDS) load_module ldiskfs
5384         local inode_slab=$(do_facet $SINGLEMDS "cat /proc/slabinfo" |
5385                            awk '/ldiskfs_inode_cache/ { print $5 / $6 }')
5386         if [ -z "$inode_slab" ]; then
5387                 skip "ldiskfs module has not been loaded"
5388         fi
5389
5390         if grep -q "CONFIG_DEBUG_LOCK_ALLOC=y" /boot/config-$(uname -r); then
5391                 skip "test is not compatible with CONFIG_DEBUG_LOCK_ALLOC=y"
5392         fi
5393
5394         echo "$inode_slab ldiskfs inodes per page"
5395         [ "${inode_slab%.*}" -ge "3" ] && return 0
5396
5397         # If kmalloc-128 is also 1 per page - this is a debug kernel
5398         # and so this is not an error.
5399         local kmalloc128=$(do_facet $SINGLEMDS "cat /proc/slabinfo" |
5400                            awk '/^(dma-kmalloc|size)-128 / { print $5 / $6 }')
5401         # 32 128-byte chunks in 4k
5402         [ "${kmalloc128%.*}" -lt "32" ] ||
5403                 error "ldiskfs inode too big, only $inode_slab objs/page, " \
5404                       "kmalloc128 = $kmalloc128 objs/page"
5405 }
5406 run_test 63 "Verify each page can at least hold 3 ldiskfs inodes"
5407
5408 test_64() {
5409         start_mds || error "unable to start MDS"
5410         start_ost || error "Unable to start OST1"
5411         start_ost2 || error "Unable to start second ost"
5412         mount_client $MOUNT || error "Unable to mount client"
5413         stop_ost2 || error "Unable to stop second ost"
5414         echo "$LFS df"
5415         $LFS df --lazy
5416         umount_client $MOUNT -f || error "unmount $MOUNT failed"
5417         cleanup_nocli || error "cleanup_nocli failed with $?"
5418         #writeconf to remove all ost2 traces for subsequent tests
5419         writeconf_or_reformat
5420 }
5421 run_test 64 "check lfs df --lazy "
5422
5423 test_65() { # LU-2237
5424         # Currently, the test is only valid for ldiskfs backend
5425         [ "$mds1_FSTYPE" != ldiskfs ] &&
5426                 skip "ldiskfs only test"
5427
5428         local devname=$(mdsdevname ${SINGLEMDS//mds/})
5429         local brpt=$(facet_mntpt brpt)
5430         local opts=""
5431
5432         if ! do_facet $SINGLEMDS "test -b $devname"; then
5433                 opts="-o loop"
5434         fi
5435
5436         stop_mds || error "Unable to stop MDS"
5437         local obj=$(do_facet $SINGLEMDS \
5438                     "$DEBUGFS -c -R \\\"stat last_rcvd\\\" $devname" |
5439                     grep Inode)
5440         if [ -z "$obj" ]; then
5441                 # The MDT may be just re-formatted, mount the MDT for the
5442                 # first time to guarantee the "last_rcvd" file is there.
5443                 start_mds || error "fail to mount the MDS for the first time"
5444                 stop_mds || error "Unable to stop MDS"
5445         fi
5446
5447         # remove the "last_rcvd" file
5448         do_facet $SINGLEMDS "mkdir -p $brpt"
5449         do_facet $SINGLEMDS \
5450                 "mount -t $mds1_FSTYPE $opts $devname $brpt"
5451         do_facet $SINGLEMDS "rm -f ${brpt}/last_rcvd"
5452         do_facet $SINGLEMDS "$UMOUNT $brpt"
5453
5454         # restart MDS, the "last_rcvd" file should be recreated.
5455         start_mds || error "fail to restart the MDS"
5456         stop_mds || error "Unable to stop MDS"
5457         obj=$(do_facet $SINGLEMDS \
5458               "$DEBUGFS -c -R \\\"stat last_rcvd\\\" $devname" | grep Inode)
5459         [ -n "$obj" ] || error "fail to re-create the last_rcvd"
5460 }
5461 run_test 65 "re-create the lost last_rcvd file when server mount"
5462
5463 test_66() {
5464         [[ "$MGS_VERSION" -ge $(version_code 2.3.59) ]] ||
5465                 skip "Need MGS version at least 2.3.59"
5466
5467         check_versions || skip "do not replace_nids with mismatched versions"
5468
5469         setup
5470         local OST1_NID=$(do_facet ost1 $LCTL list_nids | head -1)
5471         local MDS_NID=$(do_facet $SINGLEMDS $LCTL list_nids | head -1)
5472
5473         # add EXCLUDE records to config log, they are not to be
5474         # removed by lctl replace_nids
5475         set_conf_param_and_check mds                                    \
5476             "$LCTL get_param -n osc.$FSNAME-OST0000-osc-MDT0000.active" \
5477             "$FSNAME-OST0000.osc.active"                                \
5478             "0"
5479
5480         echo "replace_nids should fail if MDS, OSTs and clients are UP"
5481         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 $OST1_NID &&
5482                 error "replace_nids fail"
5483
5484         umount_client $MOUNT || error "unmounting client failed"
5485         echo "replace_nids should fail if MDS and OSTs are UP"
5486         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 $OST1_NID &&
5487                 error "replace_nids fail"
5488
5489         stop_ost || error "Unable to stop OST1"
5490         echo "replace_nids should fail if MDS is UP"
5491         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 $OST1_NID &&
5492                 error "replace_nids fail"
5493
5494         stop_mds || error "stopping mds failed"
5495
5496         if combined_mgs_mds; then
5497                 start_mdt 1 "-o nosvc" ||
5498                         error "starting mds with nosvc option failed"
5499         fi
5500
5501         echo "command should accept two parameters"
5502         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 &&
5503                 error "command should accept two params"
5504
5505         echo "correct device name should be passed"
5506         do_facet mgs $LCTL replace_nids $FSNAME-WRONG0000 $OST1_NID &&
5507                 error "wrong devname"
5508
5509         echo "wrong nids list should not destroy the system"
5510         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 "wrong nids list" &&
5511                 error "wrong parse"
5512         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 "asdfasdf, asdfadf" &&
5513                 error "wrong parse"
5514
5515         echo "replace OST nid"
5516         do_facet mgs $LCTL replace_nids $FSNAME-OST0000 $OST1_NID ||
5517                 error "replace nids failed"
5518
5519         echo "command should accept two parameters"
5520         do_facet mgs $LCTL replace_nids $FSNAME-MDT0000 &&
5521                 error "command should accept two params"
5522
5523         echo "wrong nids list should not destroy the system"
5524         do_facet mgs $LCTL replace_nids $FSNAME-MDT0000 "wrong nids list" &&
5525                 error "wrong parse"
5526
5527         local FAKE_NIDS="192.168.0.112@tcp1,192.168.0.112@tcp2"
5528         local FAKE_FAILOVER="192.168.0.113@tcp1,192.168.0.113@tcp2"
5529         local NIDS_AND_FAILOVER="$MDS_NID,$FAKE_NIDS:$FAKE_FAILOVER"
5530         echo "set NIDs with failover"
5531         do_facet mgs $LCTL replace_nids $FSNAME-MDT0000 $NIDS_AND_FAILOVER ||
5532                 error "replace nids failed"
5533
5534
5535         echo "replace MDS nid"
5536         do_facet mgs $LCTL replace_nids $FSNAME-MDT0000 $MDS_NID ||
5537                 error "replace nids failed"
5538
5539         if ! combined_mgs_mds ; then
5540                 stop_mgs
5541         else
5542                 stop_mds || error "Unable to stop MDS"
5543         fi
5544
5545         start_mgsmds || error "start mgsmds failed"
5546         set_conf_param_and_check mds                                    \
5547             "$LCTL get_param -n osc.$FSNAME-OST0000-osc-MDT0000.active" \
5548             "$FSNAME-OST0000.osc.active"                                \
5549             "1"
5550         start_ost || error "unable to start OST"
5551         mount_client $MOUNT || error "mount client failed"
5552
5553         check_mount || error "error after nid replace"
5554         cleanup || error "cleanup failed"
5555         reformat_and_config
5556 }
5557 run_test 66 "replace nids"
5558
5559 test_67() { #LU-2950
5560         local legacy="$TMP/legacy_lnet_config"
5561         local new="$TMP/new_routes_test"
5562         local out="$TMP/config_out_file"
5563         local verify="$TMP/conv_verify"
5564         local verify_conf="$TMP/conf_verify"
5565
5566         # Create the legacy file that will be run through the
5567         # lustre_routes_conversion script
5568         cat <<- LEGACY_LNET_CONFIG > $legacy
5569                 tcp1 23 192.168.213.1@tcp:1; tcp5 34 193.30.4.3@tcp:4;
5570                 tcp2 54 10.1.3.2@tcp;
5571                 tcp3 10.3.4.3@tcp:3;
5572                 tcp4 10.3.3.4@tcp;
5573         LEGACY_LNET_CONFIG
5574
5575         # Create the verification file to verify the output of
5576         # lustre_routes_conversion script against.
5577         cat <<- VERIFY_LNET_CONFIG > $verify
5578                 tcp1: { gateway: 192.168.213.1@tcp, hop: 23, priority: 1 }
5579                 tcp5: { gateway: 193.30.4.3@tcp, hop: 34, priority: 4 }
5580                 tcp2: { gateway: 10.1.3.2@tcp, hop: 54 }
5581                 tcp3: { gateway: 10.3.4.3@tcp, priority: 3 }
5582                 tcp4: { gateway: 10.3.3.4@tcp }
5583         VERIFY_LNET_CONFIG
5584
5585         # Create the verification file to verify the output of
5586         # lustre_routes_config script against
5587         cat <<- VERIFY_LNET_CONFIG > $verify_conf
5588                 lctl --net tcp1 add_route 192.168.213.1@tcp 23 1
5589                 lctl --net tcp5 add_route 193.30.4.3@tcp 34 4
5590                 lctl --net tcp2 add_route 10.1.3.2@tcp 54 4
5591                 lctl --net tcp3 add_route 10.3.4.3@tcp 1 3
5592                 lctl --net tcp4 add_route 10.3.3.4@tcp 1 3
5593         VERIFY_LNET_CONFIG
5594
5595         $LUSTRE_ROUTES_CONVERSION $legacy $new > /dev/null
5596         if [ -f $new ]; then
5597                 # verify the conversion output
5598                 cmp -s $new $verify > /dev/null
5599                 if [ $? -eq 1 ]; then
5600                         error "routes conversion failed"
5601                 fi
5602
5603                 lustre_routes_config --dry-run --verbose $new > $out
5604                 # check that the script succeeded
5605                 cmp -s $out $verify_conf > /dev/null
5606                 if [ $? -eq 1 ]; then
5607                         error "routes config failed"
5608                 fi
5609         else
5610                 error "routes conversion test failed"
5611         fi
5612         # remove generated files
5613         rm -f $new $legacy $verify $verify_conf $out
5614 }
5615 run_test 67 "test routes conversion and configuration"
5616
5617 test_68() {
5618         local fid
5619         local seq
5620         local START
5621         local END
5622
5623         [ "$MDS1_VERSION" -ge $(version_code 2.4.53) ] ||
5624                 skip "Need MDS version at least 2.4.53"
5625
5626         umount_client $MOUNT || error "umount client failed"
5627
5628         start_mgsmds
5629         start_ost
5630
5631         # START-END - the sequences we'll be reserving
5632         START=$(do_facet $SINGLEMDS \
5633                 $LCTL get_param -n seq.ctl*.space | awk -F'[[ ]' '{print $2}')
5634         END=$((START + (1 << 30)))
5635         do_facet $SINGLEMDS \
5636                 $LCTL set_param seq.ctl*.fldb="[$START-$END\):0:mdt"
5637
5638         # reset the sequences MDT0000 has already assigned
5639         do_facet $SINGLEMDS \
5640                 $LCTL set_param seq.srv*MDT0000.space=clear
5641
5642         # remount to let the client allocate new sequence
5643         mount_client $MOUNT || error "mount client failed"
5644
5645         touch $DIR/$tfile || error "touch $DIR/$tfile failed"
5646         do_facet $SINGLEMDS \
5647                 $LCTL get_param seq.srv*MDT0000.space
5648         $LFS path2fid $DIR/$tfile
5649
5650         local old_ifs="$IFS"
5651         IFS='[:]'
5652         fid=($($LFS path2fid $DIR/$tfile))
5653         IFS="$old_ifs"
5654         let seq=${fid[1]}
5655
5656         if [[ $seq < $END ]]; then
5657                 error "used reserved sequence $seq?"
5658         fi
5659         cleanup || error "cleanup failed with $?"
5660 }
5661 run_test 68 "be able to reserve specific sequences in FLDB"
5662
5663 # Test 69: is about the total number of objects ever created on an OST.
5664 # so that when it is reformatted the normal MDS->OST orphan recovery won't
5665 # just "precreate" the missing objects. In the past it might try to recreate
5666 # millions of objects after an OST was reformatted
5667 test_69() {
5668         [[ "$MDS1_VERSION" -lt $(version_code 2.4.2) ]] &&
5669                 skip "Need MDS version at least 2.4.2"
5670
5671         [[ "$MDS1_VERSION" -ge $(version_code 2.4.50) ]] &&
5672         [[ "$MDS1_VERSION" -lt $(version_code 2.5.0) ]] &&
5673                 skip "Need MDS version at least 2.5.0"
5674
5675         setup
5676         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
5677         do_nodes $(comma_list $(osts_nodes)) $LCTL set_param \
5678                 seq.*OST*-super.width=$DATA_SEQ_MAX_WIDTH
5679
5680         # use OST0000 since it probably has the most creations
5681         local OSTNAME=$(ostname_from_index 0)
5682         local mdtosc_proc1=$(get_mdtosc_proc_path mds1 $OSTNAME)
5683         local last_id=$(do_facet mds1 $LCTL get_param -n \
5684                         osp.$mdtosc_proc1.prealloc_last_id)
5685
5686         # Want to have OST LAST_ID over 5 * OST_MAX_PRECREATE to
5687         # verify that the LAST_ID recovery is working properly. If
5688         # not, then the OST will refuse to allow the MDS connect
5689         # because the LAST_ID value is too different from the MDS
5690         #define OST_MAX_PRECREATE=20000
5691         local ost_max_pre=20000
5692         local num_create=$(( ost_max_pre * 5 + 1 - last_id))
5693
5694         # If the LAST_ID is already over 5 * OST_MAX_PRECREATE, we don't
5695         # need to create any files. So, skip this section.
5696         if [ $num_create -gt 0 ]; then
5697                 # Check the number of inodes available on OST0
5698                 local files=0
5699                 local ifree=$($LFS df -i $MOUNT |
5700                         awk '/OST0000/ { print $4 }'; exit ${PIPESTATUS[0]})
5701                 log "On OST0, $ifree inodes available. Want $num_create. rc=$?"
5702
5703                 $LFS setstripe -i 0 $DIR/$tdir ||
5704                         error "$LFS setstripe -i 0 $DIR/$tdir failed"
5705                 if [ $ifree -lt 10000 ]; then
5706                         files=$(( ifree - 50 ))
5707                 else
5708                         files=10000
5709                 fi
5710
5711                 local j=$((num_create / files + 1))
5712                 for i in $(seq 1 $j); do
5713                         createmany -o $DIR/$tdir/$tfile-$i- $files ||
5714                                 error "createmany fail create $files files: $?"
5715                         unlinkmany $DIR/$tdir/$tfile-$i- $files ||
5716                                 error "unlinkmany failed unlink $files files"
5717                 done
5718         fi
5719
5720         # delete all of the files with objects on OST0 so the
5721         # filesystem is not inconsistent later on
5722         $LFS find $MOUNT --ost 0 -print0 | xargs -0 rm
5723
5724         umount_client $MOUNT || error "umount client failed"
5725         stop_ost || error "OST0 stop failure"
5726         add ost1 $(mkfs_opts ost1 $(ostdevname 1)) --reformat --replace \
5727                 $(ostdevname 1) $(ostvdevname 1) ||
5728                 error "reformat and replace $ostdev failed"
5729         start_ost || error "OST0 restart failure"
5730         wait_osc_import_state mds ost FULL
5731
5732         mount_client $MOUNT || error "mount client failed"
5733         touch $DIR/$tdir/$tfile-last || error "create file after reformat"
5734         local idx=$($LFS getstripe -i $DIR/$tdir/$tfile-last)
5735         [ $idx -ne 0 ] && error "$DIR/$tdir/$tfile-last on $idx not 0" || true
5736
5737         local iused=$($LFS df -i $MOUNT |
5738                 awk '/OST0000/ { print $3 }'; exit ${PIPESTATUS[0]})
5739         log "On OST0, $iused used inodes rc=$?"
5740         [ $iused -ge $((ost_max_pre + 1000)) ] &&
5741                 error "OST replacement created too many inodes; $iused"
5742         cleanup || error "cleanup failed with $?"
5743 }
5744 run_test 69 "replace an OST with the same index"
5745
5746 test_70a() {
5747         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5748         local MDTIDX=1
5749
5750         cleanup || error "cleanup failed with $?"
5751
5752         start_mdt 1 || error "MDT0 start fail"
5753
5754         start_ost || error "OST0 start fail"
5755         for num in $(seq 2 $MDSCOUNT); do
5756                 start_mdt $num || return
5757         done
5758
5759         mount_client $MOUNT || error "mount client fails"
5760
5761         mkdir $DIR/$tdir || error "create $DIR/$tdir failed"
5762
5763         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
5764                 error "create remote dir fail"
5765
5766         rm -rf $DIR/$tdir || error "delete dir fail"
5767         cleanup || error "cleanup failed with $?"
5768 }
5769 run_test 70a "start MDT0, then OST, then MDT1"
5770
5771 test_70b() {
5772         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5773         local MDTIDX=1
5774
5775         start_ost || error "OST0 start fail"
5776
5777         start_mds || error "MDS start fail"
5778
5779         mount_client $MOUNT || error "mount client fails"
5780
5781         mkdir $DIR/$tdir || error "create $DIR/$tdir failed"
5782
5783         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
5784                 error "create remote dir fail"
5785
5786         rm -rf $DIR/$tdir || error "delete dir fail"
5787
5788         cleanup || error "cleanup failed with $?"
5789 }
5790 run_test 70b "start OST, MDT1, MDT0"
5791
5792 test_70c() {
5793         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5794         local MDTIDX=1
5795
5796         start_mds || error "MDS start fail"
5797         start_ost || error "OST0 start fail"
5798
5799         mount_client $MOUNT || error "mount client fails"
5800         stop_mdt 1 || error "MDT1 start fail"
5801
5802         local mdc_for_mdt1=$($LCTL dl | grep MDT0000-mdc | awk '{print $4}')
5803         echo "deactivate $mdc_for_mdt1"
5804         $LCTL --device $mdc_for_mdt1 deactivate ||
5805                 error "set $mdc_for_mdt1 deactivate failed"
5806
5807         mkdir $DIR/$tdir && error "mkdir succeed"
5808
5809         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir &&
5810                 error "create remote dir succeed"
5811
5812         cleanup || error "cleanup failed with $?"
5813 }
5814 run_test 70c "stop MDT0, mkdir fail, create remote dir fail"
5815
5816 test_70d() {
5817         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5818         local MDTIDX=1
5819
5820         start_mds || error "MDS start fail"
5821         start_ost || error "OST0 start fail"
5822
5823         mount_client $MOUNT || error "mount client fails"
5824
5825         stop_mdt 2 || error "MDT1 start fail"
5826
5827         local mdc_for_mdt2=$($LCTL dl | grep MDT0001-mdc |
5828                              awk '{print $4}')
5829         echo "deactivate $mdc_for_mdt2"
5830         $LCTL --device $mdc_for_mdt2 deactivate ||
5831                 error "set $mdc_for_mdt2 deactivate failed"
5832
5833         mkdir $DIR/$tdir || error "mkdir fail"
5834         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir &&
5835                 error "create remote dir succeed"
5836
5837         rm -rf $DIR/$tdir || error "delete dir fail"
5838
5839         cleanup || error "cleanup failed with $?"
5840 }
5841 run_test 70d "stop MDT1, mkdir succeed, create remote dir fail"
5842
5843 test_70e() {
5844         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5845
5846         [ "$MDS1_VERSION" -ge $(version_code 2.7.62) ] ||
5847                 skip "Need MDS version at least 2.7.62"
5848
5849         reformat || error "reformat failed with $?"
5850
5851         load_modules
5852
5853         local mdsdev=$(mdsdevname 1)
5854         local ostdev=$(ostdevname 1)
5855         local mdsvdev=$(mdsvdevname 1)
5856         local ostvdev=$(ostvdevname 1)
5857         local opts_mds="$(mkfs_opts mds1 $mdsdev) --reformat $mdsdev $mdsvdev"
5858         local opts_ost="$(mkfs_opts ost1 $ostdev) --reformat $ostdev $ostvdev"
5859
5860         if ! combined_mgs_mds ; then
5861                 start_mgs
5862         fi
5863
5864         add mds1 $opts_mds || error "add mds1 failed"
5865         start_mdt 1 || error "start mdt1 failed"
5866         add ost1 $opts_ost || error "add ost1 failed"
5867         start_ost || error "start ost failed"
5868         mount_client $MOUNT > /dev/null || error "mount client $MOUNT failed"
5869
5870         local soc=$(do_facet mds1 "$LCTL get_param -n \
5871                     mdt.*MDT0000.sync_lock_cancel")
5872         [ $soc == "never" ] || error "SoC enabled on single MDS"
5873
5874         for i in $(seq 2 $MDSCOUNT); do
5875                 mdsdev=$(mdsdevname $i)
5876                 mdsvdev=$(mdsvdevname $i)
5877                 opts_mds="$(mkfs_opts mds$i $mdsdev) --reformat $mdsdev \
5878                           $mdsvdev"
5879                 add mds$i $opts_mds || error "add mds$i failed"
5880                 start_mdt $i || error "start mdt$i fail"
5881         done
5882
5883         wait_dne_interconnect
5884
5885         for i in $(seq $MDSCOUNT); do
5886                 soc=$(do_facet mds$i "$LCTL get_param -n \
5887                         mdt.*MDT000$((i - 1)).sync_lock_cancel")
5888                 [ $soc == "blocking" ] || error "SoC not enabled on DNE"
5889         done
5890
5891         for i in $(seq 2 $MDSCOUNT); do
5892                 stop_mdt $i || error "stop mdt$i fail"
5893         done
5894         soc=$(do_facet mds1 "$LCTL get_param -n \
5895                 mdt.*MDT0000.sync_lock_cancel")
5896         [ $soc == "never" ] || error "SoC enabled on single MDS"
5897         umount_client $MOUNT -f > /dev/null
5898
5899         cleanup || error "cleanup failed with $?"
5900 }
5901 run_test 70e "Sync-on-Cancel will be enabled by default on DNE"
5902
5903 test_71a() {
5904         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5905         if combined_mgs_mds; then
5906                 skip "needs separate MGS/MDT"
5907         fi
5908         local MDTIDX=1
5909
5910         start_mdt 1 || error "MDT0 start fail"
5911         start_ost || error "OST0 start fail"
5912         for num in $(seq 2 $MDSCOUNT); do
5913                 start_mdt $num || return
5914         done
5915
5916         start_ost2 || error "OST1 start fail"
5917
5918         mount_client $MOUNT || error "mount client fails"
5919
5920         mkdir $DIR/$tdir || error "mkdir fail"
5921         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
5922                 error "create remote dir succeed"
5923
5924         mcreate $DIR/$tdir/remote_dir/$tfile || error "create file failed"
5925         rm -rf $DIR/$tdir || error "delete dir fail"
5926
5927         umount_client $MOUNT || error "umount_client failed"
5928         stop_mds || error "MDS stop fail"
5929         stop_ost || error "OST0 stop fail"
5930         stop_ost2 || error "OST1 stop fail"
5931 }
5932 run_test 71a "start MDT0 OST0, MDT1, OST1"
5933
5934 test_71b() {
5935         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5936         if combined_mgs_mds; then
5937                 skip "needs separate MGS/MDT"
5938         fi
5939         local MDTIDX=1
5940
5941         for num in $(seq 2 $MDSCOUNT); do
5942                 start_mdt $num || return
5943         done
5944         start_ost || error "OST0 start fail"
5945         start_mdt 1 || error "MDT0 start fail"
5946         start_ost2 || error "OST1 start fail"
5947
5948         mount_client $MOUNT || error "mount client fails"
5949
5950         mkdir $DIR/$tdir || error "mkdir fail"
5951         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
5952                 error "create remote dir succeed"
5953
5954         mcreate $DIR/$tdir/remote_dir/$tfile || error "create file failed"
5955         rm -rf $DIR/$tdir || error "delete dir fail"
5956
5957         umount_client $MOUNT || error "umount_client failed"
5958         stop_mds || error "MDT0 stop fail"
5959         stop_ost || error "OST0 stop fail"
5960         stop_ost2 || error "OST1 stop fail"
5961 }
5962 run_test 71b "start MDT1, OST0, MDT0, OST1"
5963
5964 test_71c() {
5965         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5966         combined_mgs_mds && skip "needs separate MGS/MDT"
5967
5968         local MDTIDX=1
5969
5970         start_ost || error "OST0 start fail"
5971         start_ost2 || error "OST1 start fail"
5972         for num in $(seq 2 $MDSCOUNT); do
5973                 start_mdt $num || return
5974         done
5975         start_mdt 1 || error "MDT0 start fail"
5976
5977         mount_client $MOUNT || error "mount client fails"
5978
5979         mkdir $DIR/$tdir || error "mkdir fail"
5980         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
5981                 error "create remote dir succeed"
5982
5983         mcreate $DIR/$tdir/remote_dir/$tfile || error "create file failed"
5984         rm -rf $DIR/$tdir || error "delete dir fail"
5985
5986         umount_client $MOUNT || error "umount_client failed"
5987         stop_mds || error "MDS stop fail"
5988         stop_ost || error "OST0 stop fail"
5989         stop_ost2 || error "OST1 stop fail"
5990
5991 }
5992 run_test 71c "start OST0, OST1, MDT1, MDT0"
5993
5994 test_71d() {
5995         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
5996         combined_mgs_mds && skip "needs separate MGS/MDT"
5997
5998         local MDTIDX=1
5999
6000         start_ost || error "OST0 start fail"
6001         for num in $(seq 2 $MDSCOUNT); do
6002                 start_mdt $num || return
6003         done
6004         start_mdt 1 || error "MDT0 start fail"
6005         start_ost2 || error "OST1 start fail"
6006
6007         mount_client $MOUNT || error "mount client fails"
6008
6009         mkdir $DIR/$tdir || error "mkdir fail"
6010         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
6011                         error "create remote dir succeed"
6012
6013         mcreate $DIR/$tdir/remote_dir/$tfile || error "create file failed"
6014         rm -rf $DIR/$tdir || error "delete dir fail"
6015
6016         umount_client $MOUNT || error "umount_client failed"
6017         stop_mds || error "MDS stop fail"
6018         stop_ost || error "OST0 stop fail"
6019         stop_ost2 || error "OST1 stop fail"
6020
6021 }
6022 run_test 71d "start OST0, MDT1, MDT0, OST1"
6023
6024 test_71e() {
6025         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
6026         combined_mgs_mds && skip "needs separate MGS/MDT"
6027
6028         local MDTIDX=1
6029
6030         start_ost || error "OST0 start fail"
6031         for num in $(seq 2 $MDSCOUNT); do
6032                 start_mdt $num || return
6033         done
6034         start_ost2 || error "OST1 start fail"
6035         start_mdt 1 || error "MDT0 start fail"
6036
6037         mount_client $MOUNT || error "mount client fails"
6038
6039         mkdir $DIR/$tdir || error "mkdir fail"
6040         $LFS mkdir -i $MDTIDX $DIR/$tdir/remote_dir ||
6041                 error "create remote dir succeed"
6042
6043         mcreate $DIR/$tdir/remote_dir/$tfile || error "create file failed"
6044         rm -rf $DIR/$tdir || error "delete dir fail"
6045
6046         umount_client $MOUNT || error "umount_client failed"
6047         stop_mds || error "MDS stop fail"
6048         stop_ost || error "OST0 stop fail"
6049         stop_ost2 || error "OST1 stop fail"
6050
6051 }
6052 run_test 71e "start OST0, MDT1, OST1, MDT0"
6053
6054 test_72() { #LU-2634
6055         [ "$mds1_FSTYPE" != ldiskfs ] &&
6056                 skip "ldiskfs only test"
6057
6058         local mdsdev=$(mdsdevname 1)
6059         local ostdev=$(ostdevname 1)
6060         local cmd="$E2FSCK -fnvd $mdsdev"
6061         local fn=3
6062         local add_options
6063
6064         cleanup
6065         load_modules
6066
6067         if combined_mgs_mds; then
6068                 add_options='--reformat'
6069         else
6070                 add_options='--reformat --replace'
6071         fi
6072
6073         #tune MDT with "-O extents"
6074
6075         for num in $(seq $MDSCOUNT); do
6076                 add mds${num} $(mkfs_opts mds$num $(mdsdevname $num)) \
6077                         $add_options $(mdsdevname $num) $(mdsvdevname $num) ||
6078                         error "add mds $num failed"
6079                 do_facet mds${num} "$TUNE2FS -O extents $(mdsdevname $num)" ||
6080                         error "$TUNE2FS failed on mds${num}"
6081         done
6082
6083         add ost1 $(mkfs_opts ost1 $ostdev) $add_options $ostdev ||
6084                 error "add $ostdev failed"
6085         start_mds || error "start mds failed"
6086         start_ost || error "start ost failed"
6087         mount_client $MOUNT || error "mount client failed"
6088
6089         #create some short symlinks
6090         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
6091         createmany -o $DIR/$tdir/$tfile-%d $fn
6092         echo "create $fn short symlinks"
6093         for i in $(seq -w 1 $fn); do
6094                 ln -s $DIR/$tdir/$tfile-$i $MOUNT/$tfile-$i
6095         done
6096         ls -al $MOUNT
6097
6098         #umount
6099         umount_client $MOUNT || error "umount client failed"
6100         stop_mds || error "stop mds failed"
6101         stop_ost || error "stop ost failed"
6102
6103         #run e2fsck
6104         run_e2fsck $(facet_active_host $SINGLEMDS) $mdsdev "-n"
6105 }
6106 run_test 72 "test fast symlink with extents flag enabled"
6107
6108 test_73() { #LU-3006
6109         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
6110         do_facet ost1 "$TUNEFS --failnode=1.2.3.4@$NETTYPE $(ostdevname 1)" ||
6111                 error "1st tunefs failed"
6112         start_mgsmds || error "start mds failed"
6113         start_ost || error "start ost failed"
6114         mount_client $MOUNT || error "mount client failed"
6115         $LCTL get_param -n osc.*OST0000-osc-[^M]*.import | grep failover_nids |
6116                 grep 1.2.3.4@$NETTYPE || error "failover nids haven't changed"
6117         umount_client $MOUNT || error "umount client failed"
6118         stop_ost
6119         stop_mds
6120 }
6121 run_test 73 "failnode to update from mountdata properly"
6122
6123 # LU-15246
6124 test_74() {
6125         (( $MDS1_VERSION >= $(version_code 2.15.57.16) )) ||
6126                 skip "need MDS version >= 2.15.57.16 for per-device timeouts"
6127
6128         setup
6129         stack_trap "cleanup"
6130
6131         # Prepare fs2, share the mgs of fs
6132         local FSNAME2=fs15246
6133         local fs2mdsdev=$(mdsdevname 1_2)
6134         local fs2ostdev=$(ostdevname 1_2)
6135         local fs2mdsvdev=$(mdsvdevname 1_2)
6136         local fs2ostvdev=$(ostvdevname 1_2)
6137
6138         add fs2mds $(mkfs_opts mds1 $fs2mdsdev) --fsname=$FSNAME2 \
6139                 --reformat $fs2mdsdev $fs2mdsvdev || error "add fs2mds failed"
6140         add fs2ost $(mkfs_opts ost1 $fs2ostdev) --fsname=$FSNAME2 \
6141                 --reformat $fs2ostdev $fs2ostvdev || error "add fs2ost failed"
6142
6143         stack_trap "cleanup_fs2"
6144
6145         start fs2ost $fs2ostdev $OST_MOUNT_OPTS || error "start fs2ost failed"
6146         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS || error "start fs2mds failed"
6147
6148         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
6149         $MOUNT_CMD $MGSNID:/$FSNAME2 $MOUNT2 || error "mount $MOUNT2 failed"
6150
6151         echo "========== All mounted lustre fs ===================="
6152         mount | grep 'type lustre'
6153         echo "====================================================="
6154
6155         # Set and check osc/ldlm_enqueue_min
6156         $LCTL set_param osc.${FSNAME}-*.ldlm_enqueue_min=99 ||
6157                 error "failed to set per-device adaptive parameters on client"
6158         stack_trap "$LCTL set_param osc.${FSNAME}-*.ldlm_enqueue_min=0"
6159
6160         local ldlm_enqueue_min
6161         ldlm_enqueue_min=$($LCTL get_param -n osc.${FSNAME}-*.ldlm_enqueue_min \
6162                            | uniq)
6163         (( $ldlm_enqueue_min == 99 )) ||
6164                 error "wrong ldlm_enqueue_min value for osc.${FSNAME}-*"
6165
6166         # Check fs2 as reference
6167         ldlm_enqueue_min=$($LCTL get_param -n osc.${FSNAME2}-*.ldlm_enqueue_min\
6168                            | uniq)
6169         (( $ldlm_enqueue_min == 0 )) ||
6170                 error "wrong ldlm_enqueue_min value for osc.${FSNAME2}-*"
6171
6172         # Set and check obdfilter/at_min
6173         do_facet ost1 $LCTL set_param obdfilter.${FSNAME}-*.at_min=1 ||
6174                 error "failed to set per-device adaptive parameters on ost"
6175         stack_trap "do_facet ost1 $LCTL set_param obdfilter.${FSNAME}-*.at_min=0"
6176
6177         local at_min
6178         at_min=$(do_facet ost1 $LCTL get_param -n obdfilter.${FSNAME}-*.at_min \
6179                 | uniq)
6180         (( $at_min == 1 )) ||
6181                 error "wrong at_min value for obdfilter.${FSNAME}-*"
6182
6183         # set and check mdc/at_max
6184         $LCTL set_param mdc.${FSNAME}-*.at_max=599 ||
6185                 error "failed to set per-device adaptive parameters on client"
6186         stack_trap "$LCTL set_param mdc.${FSNAME}-*.at_max=0"
6187
6188         local at_max
6189         at_max=$($LCTL get_param -n mdc.${FSNAME}-*.at_max | uniq)
6190         (( $at_max == 599 )) ||
6191                 error "wrong at_max value for osc.${FSNAME}-*"
6192
6193         # Check fs2 as reference
6194         at_max=$($LCTL get_param -n mdc.${FSNAME2}-*.at_max | uniq)
6195         (( $at_max == 0 )) ||
6196                 error "wrong at_max value for osc.${FSNAME2}-*"
6197
6198         # Set and check mds/at_max
6199         do_facet mds1 $LCTL set_param *.${FSNAME}-*.at_max=599 ||
6200                 error "failed to set per-device adaptive parameters on mds"
6201         stack_trap "do_facet mds1 $LCTL set_param *.${FSNAME}-*.at_max=0"
6202
6203         local at_max
6204         at_max=$(do_facet mds1 $LCTL get_param -n mdt.${FSNAME}-*.at_max | uniq)
6205         (( at_max == 599 )) ||
6206                 error "wrong at_max value for mdt.${FSNAME}-*"
6207
6208         # Set and check mgs&mgc/at_history
6209         local mgs_nid=$(do_facet $SINGLEMDS $LCTL list_nids | tail -1)
6210         $LCTL set_param mgc.MGC$mgs_nid.at_history=588
6211         stack_trap "$LCTL set_param mgc.MGC$mgs_nid.at_history=0"
6212
6213         local at_history
6214         at_history=$($LCTL get_param -n mgc.MGC$mgs_nid.at_history)
6215         (( $at_history == 588 )) ||
6216                 error "wrong at_history value for mgc.MGC$mgs_nid"
6217
6218         do_facet mgs $LCTL set_param mgs.MGS.at_history=588
6219         stack_trap "do_facet mgs $LCTL set_param mgs.MGS.at_history=0"
6220         at_history=$(do_facet mgs $LCTL get_param -n mgs.MGS.at_history)
6221         (( $at_history == 588 )) ||
6222                 error "wrong at_history value for mgs.MGS"
6223 }
6224 run_test 74 "Test per-device adaptive timeout parameters"
6225
6226 test_75() { # LU-2374
6227         [[ "$MDS1_VERSION" -lt $(version_code 2.4.1) ]] &&
6228                 skip "Need MDS version at least 2.4.1"
6229
6230         local index=0
6231         local opts_mds="$(mkfs_opts mds1 $(mdsdevname 1)) \
6232                 --replace --reformat $(mdsdevname 1) $(mdsvdevname 1)"
6233         local opts_ost="$(mkfs_opts ost1 $(ostdevname 1)) \
6234                 --replace --reformat $(ostdevname 1) $(ostvdevname 1)"
6235
6236         load_modules
6237         #check with default parameters
6238         add mds1 $opts_mds || error "add mds1 failed for default params"
6239         add ost1 $opts_ost || error "add ost1 failed for default params"
6240
6241         opts_mds=$(echo $opts_mds | sed -e "s/--mdt//")
6242         opts_mds=$(echo $opts_mds |
6243                    sed -e "s/--index=$index/--index=$index --mdt/")
6244         opts_ost=$(echo $opts_ost | sed -e "s/--ost//")
6245         opts_ost=$(echo $opts_ost |
6246                    sed -e "s/--index=$index/--index=$index --ost/")
6247
6248         add mds1 $opts_mds || error "add mds1 failed for new params"
6249         add ost1 $opts_ost || error "add ost1 failed for new params"
6250
6251         reformat_and_config
6252         return 0
6253 }
6254 run_test 75 "The order of --index should be irrelevant"
6255
6256 test_76a() {
6257         [[ "$MGS_VERSION" -ge $(version_code 2.4.52) ]] ||
6258                 skip "Need MDS version at least 2.4.52"
6259
6260         setup
6261         local MDMB_PARAM="osc.*.max_dirty_mb"
6262         echo "Change MGS params"
6263         local MAX_DIRTY_MB=$($LCTL get_param -n $MDMB_PARAM |
6264                 head -1)
6265         echo "max_dirty_mb: $MAX_DIRTY_MB"
6266         local NEW_MAX_DIRTY_MB=$((MAX_DIRTY_MB - 10))
6267         echo "new_max_dirty_mb: $NEW_MAX_DIRTY_MB"
6268         do_facet mgs $LCTL set_param -P $MDMB_PARAM=$NEW_MAX_DIRTY_MB
6269         wait_update $HOSTNAME "$LCTL get_param -n $MDMB_PARAM |
6270                 head -1" $NEW_MAX_DIRTY_MB
6271         MAX_DIRTY_MB=$($LCTL get_param -n $MDMB_PARAM | head -1)
6272         echo "$MAX_DIRTY_MB"
6273         [ $MAX_DIRTY_MB = $NEW_MAX_DIRTY_MB ] ||
6274                 error "error while apply max_dirty_mb"
6275
6276         echo "Check the value is stored after remount"
6277         stopall
6278         setupall
6279         wait_update $HOSTNAME "$LCTL get_param -n $MDMB_PARAM |
6280                 head -1" $NEW_MAX_DIRTY_MB
6281         MAX_DIRTY_MB=$($LCTL get_param -n $MDMB_PARAM | head -1)
6282         [ $MAX_DIRTY_MB = $NEW_MAX_DIRTY_MB ] ||
6283                 error "max_dirty_mb is not saved after remount"
6284
6285         echo "Change OST params"
6286         CLIENT_PARAM="obdfilter.*.client_cache_count"
6287         local CLIENT_CACHE_COUNT
6288         CLIENT_CACHE_COUNT=$(do_facet ost1 $LCTL get_param -n $CLIENT_PARAM |
6289                 head -1)
6290         echo "client_cache_count: $CLIENT_CACHE_COUNT"
6291         NEW_CLIENT_CACHE_COUNT=$((CLIENT_CACHE_COUNT+CLIENT_CACHE_COUNT))
6292         echo "new_client_cache_count: $NEW_CLIENT_CACHE_COUNT"
6293         do_facet mgs $LCTL set_param -P $CLIENT_PARAM=$NEW_CLIENT_CACHE_COUNT
6294         wait_update $(facet_host ost1) "$LCTL get_param -n $CLIENT_PARAM |
6295                 head -1" $NEW_CLIENT_CACHE_COUNT
6296         CLIENT_CACHE_COUNT=$(do_facet ost1 $LCTL get_param -n $CLIENT_PARAM |
6297                 head -1)
6298         echo "$CLIENT_CACHE_COUNT"
6299         [ $CLIENT_CACHE_COUNT = $NEW_CLIENT_CACHE_COUNT ] ||
6300                 error "error while apply client_cache_count"
6301
6302         echo "Check the value is stored after remount"
6303         stopall
6304         setupall
6305         wait_update $(facet_host ost1) "$LCTL get_param -n $CLIENT_PARAM |
6306                 head -1" $NEW_CLIENT_CACHE_COUNT
6307         CLIENT_CACHE_COUNT=$(do_facet ost1 $LCTL get_param -n $CLIENT_PARAM |
6308                 head -1)
6309         echo "$CLIENT_CACHE_COUNT"
6310         [ $CLIENT_CACHE_COUNT = $NEW_CLIENT_CACHE_COUNT ] ||
6311                 error "client_cache_count is not saved after remount"
6312         stopall
6313 }
6314 run_test 76a "set permanent params with lctl across mounts"
6315
6316 test_76b() { # LU-4783
6317         [[ "$MGS_VERSION" -ge $(version_code 2.5.57) ]] ||
6318                 skip "Need MGS version at least 2.5.57"
6319         stopall
6320         setupall
6321         do_facet mgs $LCTL get_param mgs.MGS.live.params ||
6322                 error "start params log failed"
6323         stopall
6324 }
6325 run_test 76b "verify params log setup correctly"
6326
6327 test_76c() {
6328         [[ "$MGS_VERSION" -ge $(version_code 2.8.54) ]] ||
6329                 skip "Need MDS version at least 2.4.52"
6330         setupall
6331         local MASK_PARAM="mdd.*.changelog_mask"
6332         echo "Change changelog_mask"
6333         do_facet mgs $LCTL set_param -P $MASK_PARAM=-CLOSE ||
6334                 error "Can't change changlog_mask"
6335         wait_update $(facet_host mds) "$LCTL get_param -n $MASK_PARAM |
6336                 grep 'CLOSE'" ""
6337
6338         echo "Check the value is stored after mds remount"
6339         stop_mds || error "Failed to stop MDS"
6340         start_mds || error "Failed to start MDS"
6341         local CHANGELOG_MASK=$(do_facet mgs $LCTL get_param -n $MASK_PARAM)
6342         echo $CHANGELOG_MASK | grep CLOSE > /dev/null &&
6343                 error "changelog_mask is not changed"
6344
6345         stopall
6346 }
6347 run_test 76c "verify changelog_mask is applied with lctl set_param -P"
6348
6349 test_76d() { #LU-9399
6350         setupall
6351
6352         local xattr_cache="llite.*.xattr_cache"
6353         local cmd="$LCTL get_param -n $xattr_cache | head -1"
6354         local new=$((($(eval $cmd) + 1) % 2))
6355
6356         echo "lctl set_param -P llite.*.xattr_cache=$new"
6357         do_facet mgs $LCTL set_param -P $xattr_cache=$new ||
6358                 error "Can't change xattr_cache"
6359         wait_update $HOSTNAME "$cmd" "$new"
6360
6361         echo "Check $xattr_cache on client $MOUNT"
6362         umount_client $MOUNT || error "umount $MOUNT failed"
6363         mount_client $MOUNT || error "mount $MOUNT failed"
6364         [ $(eval $cmd) -eq $new ] ||
6365                 error "$xattr_cache != $new on client $MOUNT"
6366
6367         echo "Check $xattr_cache on the new client $MOUNT2"
6368         mount_client $MOUNT2 || error "mount $MOUNT2 failed"
6369         [ $(eval $cmd) -eq $new ] ||
6370                 error "$xattr_cache != $new on client $MOUNT2"
6371         umount_client $MOUNT2 || error "umount $MOUNT2 failed"
6372
6373         stopall
6374 }
6375 run_test 76d "verify llite.*.xattr_cache can be set by 'lctl set_param -P' correctly"
6376
6377 test_77() { # LU-3445
6378         [[ "$MDS1_VERSION" -ge $(version_code 2.8.55) ]] ||
6379                 skip "Need MDS version 2.8.55+ "
6380
6381         if [[ -z "$fs2ost_DEV" || -z "$fs2mds_DEV" ]]; then
6382                 is_blkdev $SINGLEMDS $(mdsdevname ${SINGLEMDS//mds/}) &&
6383                 skip_env "mixed loopback and real device not working"
6384         fi
6385
6386         local fs2mdsdev=$(mdsdevname 1_2)
6387         local fs2ostdev=$(ostdevname 1_2)
6388         local fs2mdsvdev=$(mdsvdevname 1_2)
6389         local fs2ostvdev=$(ostvdevname 1_2)
6390         local fsname=test1234
6391         local mgsnid
6392         local failnid="$(h2nettype 1.2.3.4),$(h2nettype 4.3.2.1)"
6393
6394         combined_mgs_mds || stop_mgs || error "stopping MGS service failed"
6395
6396         add fs2mds $(mkfs_opts mds1 $fs2mdsdev) --mgs --fsname=$fsname \
6397                 --reformat $fs2mdsdev $fs2mdsvdev || error "add fs2mds failed"
6398         start fs2mds $fs2mdsdev $MDS_MOUNT_OPTS && trap cleanup_fs2 EXIT INT ||
6399                 error "start fs2mds failed"
6400
6401         mgsnid=$(do_facet fs2mds $LCTL list_nids | xargs | tr ' ' ,)
6402         mgsnid="0.0.0.0@tcp,$mgsnid,$mgsnid:$mgsnid"
6403
6404         add fs2ost --mgsnode=$mgsnid $(mkfs_opts ost1 $fs2ostdev) \
6405                 --failnode=$failnid --fsname=$fsname \
6406                 --reformat $fs2ostdev $fs2ostvdev ||
6407                         error "add fs2ost failed"
6408         start fs2ost $fs2ostdev $OST_MOUNT_OPTS || error "start fs2ost failed"
6409
6410         mkdir -p $MOUNT2 || error "mkdir $MOUNT2 failed"
6411         $MOUNT_CMD $mgsnid:/$fsname $MOUNT2 || error "mount $MOUNT2 failed"
6412         DIR=$MOUNT2 MOUNT=$MOUNT2 check_mount || error "check $MOUNT2 failed"
6413         cleanup_fs2
6414 }
6415 run_test 77 "comma-separated MGS NIDs and failover node NIDs"
6416
6417 test_78() {
6418         [[ "$mds1_FSTYPE" != ldiskfs ||
6419            "$ost1_FSTYPE" != ldiskfs ]] &&
6420                 skip "ldiskfs only test"
6421
6422         # reformat the Lustre filesystem with a smaller size
6423         local saved_MDSCOUNT=$MDSCOUNT
6424         local saved_MDSSIZE=$MDSSIZE
6425         local saved_OSTCOUNT=$OSTCOUNT
6426         local saved_OSTSIZE=$OSTSIZE
6427         MDSCOUNT=1
6428         OSTCOUNT=1
6429         MDSSIZE=$((MDSSIZE - 20000))
6430         OSTSIZE=$((OSTSIZE - 20000))
6431         reformat || error "(1) reformat Lustre filesystem failed"
6432         MDSSIZE=$saved_MDSSIZE
6433         OSTSIZE=$saved_OSTSIZE
6434
6435         # mount the Lustre filesystem
6436         setup_noconfig || error "(2) setup Lustre filesystem failed"
6437
6438         # create some files
6439         log "create test files"
6440         local i
6441         local file
6442         local num_files=100
6443
6444         mkdir $MOUNT/$tdir || error "(3) mkdir $MOUNT/$tdir failed"
6445         $LFS df; $LFS df -i
6446         for i in $(seq $num_files); do
6447                 file=$MOUNT/$tdir/$tfile-$i
6448                 dd if=/dev/urandom of=$file count=1 bs=1M || {
6449                         $LCTL get_param osc.*.cur*grant*
6450                         $LFS df; $LFS df -i;
6451                         # stop creating files if there is no more space
6452                         if [ ! -e $file ]; then
6453                                 num_files=$((i - 1))
6454                                 break
6455                         fi
6456
6457                         $LFS getstripe -v $file
6458                         local ost_idx=$(LFS getstripe -i $file)
6459                         do_facet ost$((ost_idx + 1)) \
6460                                 $LCTL get_param obdfilter.*.*grant*
6461                         error "(4) create $file failed"
6462                 }
6463         done
6464
6465         # unmount the Lustre filesystem
6466         cleanup || error "(5) cleanup Lustre filesystem failed"
6467
6468         # run e2fsck on the MDT and OST devices
6469         local mds_host=$(facet_active_host $SINGLEMDS)
6470         local ost_host=$(facet_active_host ost1)
6471         local mds_dev=$(mdsdevname ${SINGLEMDS//mds/})
6472         local ost_dev=$(ostdevname 1)
6473
6474         run_e2fsck $mds_host $mds_dev "-y"
6475         run_e2fsck $ost_host $ost_dev "-y"
6476
6477         # get the original block count of the MDT and OST filesystems
6478         local mds_orig_blks=$(get_block_count $SINGLEMDS $mds_dev)
6479         local ost_orig_blks=$(get_block_count ost1 $ost_dev)
6480
6481         # expand the MDT and OST filesystems to the device size
6482         run_resize2fs $SINGLEMDS $mds_dev "" || error "expand $SINGLEMDS failed"
6483         run_resize2fs ost1 $ost_dev "" || error "expand ost1 failed"
6484
6485         # run e2fsck on the MDT and OST devices again
6486         run_e2fsck $mds_host $mds_dev "-y"
6487         run_e2fsck $ost_host $ost_dev "-y"
6488
6489         # mount the Lustre filesystem
6490         setup
6491
6492         # check the files
6493         log "check files after expanding the MDT and OST filesystems"
6494         for i in $(seq $num_files); do
6495                 file=$MOUNT/$tdir/$tfile-$i
6496                 $CHECKSTAT -t file -s 1048576 $file ||
6497                         error "(6) checkstat $file failed"
6498         done
6499
6500         # create more files
6501         log "create more files after expanding the MDT and OST filesystems"
6502         for i in $(seq $((num_files + 1)) $((num_files + 10))); do
6503                 file=$MOUNT/$tdir/$tfile-$i
6504                 dd if=/dev/urandom of=$file count=1 bs=1M ||
6505                         error "(7) create $file failed"
6506         done
6507
6508         # unmount the Lustre filesystem
6509         cleanup || error "(8) cleanup Lustre filesystem failed"
6510
6511         # run e2fsck on the MDT and OST devices
6512         run_e2fsck $mds_host $mds_dev "-y"
6513         run_e2fsck $ost_host $ost_dev "-y"
6514
6515         # get the maximum block count of the MDT and OST filesystems
6516         local mds_max_blks=$(get_block_count $SINGLEMDS $mds_dev)
6517         local ost_max_blks=$(get_block_count ost1 $ost_dev)
6518
6519         # get the minimum block count of the MDT and OST filesystems
6520         local mds_min_blks=$(run_resize2fs $SINGLEMDS $mds_dev "" "-P" 2>&1 |
6521                                 grep minimum | sed -e 's/^.*filesystem: //g')
6522         local ost_min_blks=$(run_resize2fs ost1 $ost_dev "" "-P" 2>&1 |
6523                                 grep minimum | sed -e 's/^.*filesystem: //g')
6524
6525         # shrink the MDT and OST filesystems to a smaller size
6526         local shrunk=false
6527         local new_blks
6528         local base_blks
6529         if [[ $mds_max_blks -gt $mds_min_blks &&
6530               $mds_max_blks -gt $mds_orig_blks ]]; then
6531                 [[ $mds_orig_blks -gt $mds_min_blks ]] &&
6532                         base_blks=$mds_orig_blks || base_blks=$mds_min_blks
6533                 new_blks=$(( (mds_max_blks - base_blks) / 2 + base_blks ))
6534                 run_resize2fs $SINGLEMDS $mds_dev $new_blks ||
6535                         error "shrink $SINGLEMDS to $new_blks failed"
6536                 shrunk=true
6537         fi
6538
6539         if [[ $ost_max_blks -gt $ost_min_blks &&
6540               $ost_max_blks -gt $ost_orig_blks ]]; then
6541                 [[ $ost_orig_blks -gt $ost_min_blks ]] &&
6542                         base_blks=$ost_orig_blks || base_blks=$ost_min_blks
6543                 new_blks=$(( (ost_max_blks - base_blks) / 2 + base_blks ))
6544                 run_resize2fs ost1 $ost_dev $new_blks ||
6545                         error "shrink ost1 to $new_blks failed"
6546                 shrunk=true
6547         fi
6548
6549         # check whether the MDT or OST filesystem was shrunk or not
6550         if ! $shrunk; then
6551                 combined_mgs_mds || stop_mgs || error "(9) stop mgs failed"
6552                 reformat_and_config ||
6553                         error "(10) reformat Lustre filesystem failed"
6554                 return 0
6555         fi
6556
6557         # run e2fsck on the MDT and OST devices again
6558         run_e2fsck $mds_host $mds_dev "-y"
6559         run_e2fsck $ost_host $ost_dev "-y"
6560
6561         # mount the Lustre filesystem again
6562         setup
6563
6564         # check the files
6565         log "check files after shrinking the MDT and OST filesystems"
6566         for i in $(seq $((num_files + 10))); do
6567                 file=$MOUNT/$tdir/$tfile-$i
6568                 $CHECKSTAT -t file -s 1048576 $file ||
6569                         error "(11) checkstat $file failed"
6570         done
6571
6572         # unmount and reformat the Lustre filesystem
6573         cleanup || error "(12) cleanup Lustre filesystem failed"
6574         combined_mgs_mds || stop_mgs || error "(13) stop mgs failed"
6575
6576         MDSCOUNT=$saved_MDSCOUNT
6577         OSTCOUNT=$saved_OSTCOUNT
6578         reformat_and_config || error "(14) reformat Lustre filesystem failed"
6579 }
6580 run_test 78 "run resize2fs on MDT and OST filesystems"
6581
6582 test_79() { # LU-4227
6583         [[ "$MDS1_VERSION" -ge $(version_code 2.5.59) ]] ||
6584                 skip "Need MDS version at least 2.5.59"
6585
6586         local mdsdev1=$(mdsdevname 1)
6587         local mdsvdev1=$(mdsvdevname 1)
6588         local mdsdev2=$(mdsdevname 2)
6589         local mdsvdev2=$(mdsvdevname 2)
6590         local ostdev1=$(ostdevname 1)
6591         local ostvdev1=$(ostvdevname 1)
6592         local opts_mds1="$(mkfs_opts mds1 $mdsdev1) --reformat"
6593         local opts_mds2="$(mkfs_opts mds2 $mdsdev2) --reformat"
6594         local opts_ost1="$(mkfs_opts ost1 $ostdev1) --reformat"
6595         local mgsnode_opt
6596
6597         # remove --mgs/--mgsnode from mkfs.lustre options
6598         opts_mds1=$(echo $opts_mds1 | sed -e "s/--mgs//")
6599
6600         mgsnode_opt=$(echo $opts_mds2 |
6601                 awk '{ for ( i = 1; i < NF; i++ )
6602                         if ( $i ~ "--mgsnode" ) { print $i; break } }')
6603         [ -n "$mgsnode_opt" ] &&
6604                 opts_mds2=$(echo $opts_mds2 | sed -e "s/$mgsnode_opt//")
6605
6606         mgsnode_opt=$(echo $opts_ost1 |
6607                 awk '{ for ( i = 1; i < NF; i++ )
6608                         if ( $i ~ "--mgsnode" ) { print $i; break } }')
6609         [ -n "$mgsnode_opt" ] &&
6610                 opts_ost1=$(echo $opts_ost1 | sed -e "s/$mgsnode_opt//")
6611         load_modules
6612         # -MGS, format a mdt without --mgs option
6613         add mds1 $opts_mds1 $mdsdev1 $mdsvdev1 &&
6614                 error "Must specify --mgs when formatting mdt combined with mgs"
6615
6616         # +MGS, format a mdt/ost without --mgsnode option
6617         add mds1 $(mkfs_opts mds1 $mdsdev1) --reformat $mdsdev1 $mdsvdev1 \
6618                 > /dev/null || error "start mds1 failed"
6619         add mds2 $opts_mds2 $mdsdev2 $mdsvdev2 &&
6620                 error "Must specify --mgsnode when formatting a mdt"
6621         add ost1 $opts_ost1 $ostdev1 $ostvdev1 &&
6622                 error "Must specify --mgsnode when formatting an ost"
6623
6624         reformat_and_config
6625 }
6626 run_test 79 "format MDT/OST without mgs option (should return errors)"
6627
6628 test_80() {
6629         start_mds || error "Failed to start MDT"
6630         start_ost || error "Failed to start OST1"
6631         uuid=$(do_facet ost1 $LCTL get_param -n mgc.*.uuid)
6632 #define OBD_FAIL_MGS_PAUSE_TARGET_CON       0x906
6633         do_facet ost1 "$LCTL set_param fail_val=10 fail_loc=0x906"
6634         do_facet mgs "$LCTL set_param fail_val=10 fail_loc=0x906"
6635         do_facet mgs "$LCTL set_param -n mgs/MGS/evict_client $uuid"
6636         sleep 30
6637         start_ost2 || error "Failed to start OST2"
6638
6639         do_facet ost1 "$LCTL set_param fail_loc=0"
6640         stop_ost2
6641         stop_ost
6642         stop_mds
6643 }
6644 run_test 80 "mgc import reconnect race"
6645
6646 #Save the original values of $OSTCOUNT and $OSTINDEX$i.
6647 save_ostindex() {
6648         local new_ostcount=$1
6649         saved_ostcount=$OSTCOUNT
6650         OSTCOUNT=$new_ostcount
6651
6652         local i
6653         local index
6654         for ((i = 1; i <= $OSTCOUNT; i++ )); do
6655                 index=OSTINDEX$i
6656                 eval saved_ostindex$i=${!index}
6657                 eval OSTINDEX$i=""
6658         done
6659 }
6660
6661 # Restore the original values of $OSTCOUNT and $OSTINDEX$i.
6662 restore_ostindex() {
6663         local i
6664         local index
6665
6666         echo "restoring OSTCOUNT=$saved_ostcount and OSTINDEXn"
6667
6668         for ((i = 1; i <= $OSTCOUNT; i++ )); do
6669                 index=saved_ostindex$i
6670                 eval OSTINDEX$i=${!index}
6671         done
6672         OSTCOUNT=$saved_ostcount
6673
6674         reformat
6675         if ! combined_mgs_mds ; then
6676                 start_mgs
6677         fi
6678 }
6679
6680 # The main purpose of this test is to ensure the OST_INDEX_LIST functions as
6681 # expected. This test uses OST_INDEX_LIST to format OSTs with a randomly
6682 # assigned index and ensures we can mount such a formatted file system
6683 test_81() { # LU-4665
6684         (( MDS1_VERSION >= $(version_code 2.6.54) )) ||
6685                 skip "Need MDS version at least 2.6.54"
6686         (( OSTCOUNT >= 3 )) || skip_env "needs >= 3 OSTs"
6687
6688         stopall
6689
6690         # Each time RANDOM is referenced, a random integer between 0 and 32767
6691         # is generated.
6692         local i
6693         local saved_ostindex1=$OSTINDEX1
6694         for i in 65535 $((RANDOM + 65536)); do
6695                 echo -e "\nFormat ost1 with --index=$i, should fail"
6696                 OSTINDEX1=$i
6697                 if add ost1 $(mkfs_opts ost1 $(ostdevname 1)) --reformat \
6698                    $(ostdevname 1) $(ostvdevname 1); then
6699                         OSTINDEX1=$saved_ostindex1
6700                         error "format ost1 with --index=$i should fail"
6701                 fi
6702         done
6703         OSTINDEX1=$saved_ostindex1
6704
6705         save_ostindex 3
6706         stack_trap restore_ostindex
6707
6708         # Format OSTs with random sparse indices.
6709         local rand_ost=$(((RANDOM * 2 % 65533) + 1))
6710         echo  "Format $OSTCOUNT OSTs with OST_INDEX_LIST=[0,$rand_ost,65534]"
6711         OST_INDEX_LIST=[0,$rand_ost,65534] formatall ||
6712                 error "formatall failed with $?"
6713
6714         # Setup and check Lustre filesystem.
6715         start_mgsmds || error "start_mgsmds failed"
6716         for ((i = 1; i <= $OSTCOUNT; i++ )); do
6717                 start ost$i $(ostdevname $i) $OST_MOUNT_OPTS ||
6718                         error "start ost$i failed"
6719         done
6720
6721         mount_client $MOUNT || error "mount client $MOUNT failed"
6722         check_mount || error "check client $MOUNT failed"
6723         $LFS df
6724
6725         # Check max_easize.
6726         local max_easize=$($LCTL get_param -n llite.*.max_easize)
6727         local xattr_size_max=$((4096 - 84)) # 4096 less ldiskfs ea overhead
6728
6729         # XATTR_SIZE_MAX less ldiskfs ea overhead
6730         large_xattr_enabled && xattr_size_max=$((65536 - 84))
6731         (( max_easize >= xattr_size_max )) ||
6732                 error "max_easize $max_easize < $xattr_size_max bytes"
6733
6734         test_mkdir $DIR/$tdir
6735         $LFS setstripe -i $rand_ost $DIR/$tdir/$tfile ||
6736                 error "error creating $tfile on ost$rand_ost"
6737         $LFS getstripe $DIR/$tdir/$tfile
6738
6739         local cmd
6740         local idx
6741         local found
6742         local uuid
6743
6744         cmd="getstripe -i $DIR/$tdir/$tfile"
6745         echo lfs $cmd
6746         found=$($LFS $cmd)
6747         (( $found == $rand_ost )) || error "index $found is not $rand_ost"
6748
6749         cmd="find $DIR/$tdir -i $rand_ost"
6750         echo lfs $cmd
6751         $LFS $cmd
6752         found=$($LFS $cmd)
6753         [[ "$found" == "$DIR/$tdir/$tfile" ]] ||
6754                 error "'lfs find' returned '$found', not '$tfile' by index"
6755
6756         $LFS osts
6757         uuid=$(ostuuid_from_index $rand_ost)
6758
6759         cmd="find $DIR/$tdir -O $uuid"
6760         echo lfs $cmd
6761         $LFS $cmd
6762         found=$($LFS $cmd)
6763
6764         [[ "$found" == "$DIR/$tdir/$tfile" ]] ||
6765                 error "'lfs find' returned '$found', not '$tfile' by UUID"
6766 }
6767 run_test 81 "sparse OST indexing"
6768
6769 # Here we exercise the stripe placement functionality on a file system that
6770 # has formatted the OST with a random index. With the file system the following
6771 # functionality is tested:
6772 #
6773 # 1. Creating a new file with a specific stripe layout.
6774 #
6775 # 2. Modifiy a existing empty file with a specific stripe layout.
6776 #
6777 # 3. Ensure we fail to set the stripe layout of a file that already has one.
6778 #
6779 # 4. If ost-index is defined we need to ensure it is the first entry in the
6780 #    ost index list returned by lfs getstripe.
6781 #
6782 # 5. Lastly ensure this functionality fails with directories.
6783 test_82a() { # LU-4665
6784         [[ "$MDS1_VERSION" -ge $(version_code 2.6.54) ]] ||
6785                 skip "Need MDS version at least 2.6.54"
6786         [[ $OSTCOUNT -ge 3 ]] || skip_env "needs >= 3 OSTs"
6787
6788         stopall
6789
6790         save_ostindex 3
6791
6792         # Format OSTs with random sparse indices.
6793         local i
6794         local index
6795         local ost_indices
6796         local LOV_V1_INSANE_STRIPE_COUNT=65532
6797         for i in $(seq $OSTCOUNT); do
6798                 index=$(((RANDOM * 2) % LOV_V1_INSANE_STRIPE_COUNT))
6799                 ost_indices+=" $index"
6800         done
6801         ost_indices=$(comma_list $ost_indices)
6802
6803         stack_trap "restore_ostindex" EXIT
6804         echo -e "\nFormat $OSTCOUNT OSTs with sparse indices $ost_indices"
6805         OST_INDEX_LIST=[$ost_indices] formatall
6806
6807         # Setup Lustre filesystem.
6808         start_mgsmds || error "start_mgsmds failed"
6809         for i in $(seq $OSTCOUNT); do
6810                 start ost$i $(ostdevname $i) $OST_MOUNT_OPTS ||
6811                         error "start ost$i failed"
6812         done
6813
6814         # Collect debug information - start of test
6815         do_nodes $(comma_list $(mdts_nodes)) \
6816                    $LCTL get_param osp.*.prealloc_*_id
6817
6818         mount_client $MOUNT || error "mount client $MOUNT failed"
6819         wait_osts_up
6820
6821         $LFS df $MOUNT
6822         check_lfs_df_ret_val $? || error "$LFS df $MOUNT failed"
6823         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
6824
6825         stack_trap "do_nodes $(comma_list $(mdts_nodes)) \
6826                    $LCTL get_param osp.*.prealloc_*_id || true" EXIT
6827
6828         # 1. If the file does not exist, new file will be created
6829         #    with specified OSTs.
6830         local file=$DIR/$tdir/$tfile-1
6831         local cmd="$LFS setstripe -o $ost_indices $file"
6832         echo -e "\n$cmd"
6833         eval $cmd || error "$cmd failed"
6834         check_stripe_count $file $OSTCOUNT
6835         check_obdidx $file $ost_indices
6836         dd if=/dev/urandom of=$file count=1 bs=1M > /dev/null 2>&1 ||
6837                 error "write $file failed"
6838
6839         # 2. If the file already exists and is an empty file, the file
6840         #    will be attached with specified layout.
6841         file=$DIR/$tdir/$tfile-2
6842         mcreate $file || error "mcreate $file failed"
6843         cmd="$LFS setstripe -o $ost_indices $file"
6844         echo -e "\n$cmd"
6845         eval $cmd || error "$cmd failed"
6846         dd if=/dev/urandom of=$file count=1 bs=1M > /dev/null 2>&1 ||
6847                 error "write $file failed"
6848         check_stripe_count $file $OSTCOUNT
6849         check_obdidx $file $ost_indices
6850
6851         # 3. If the file already has a valid layout attached, the command
6852         #    should fail with EBUSY.
6853         echo -e "\n$cmd"
6854         eval $cmd && error "stripe is already set on $file, $cmd should fail"
6855
6856         # 4. If [--stripe-index|-i <start_ost_idx>] is used, the index must
6857         #    be in the OST indices list.
6858         local start_ost_idx=${ost_indices##*,}
6859         file=$DIR/$tdir/$tfile-3
6860         cmd="$LFS setstripe -o $ost_indices -i $start_ost_idx $file"
6861         echo -e "\n$cmd"
6862         eval $cmd || error "$cmd failed"
6863         check_stripe_count $file $OSTCOUNT
6864         check_obdidx $file $ost_indices
6865         check_start_ost_idx $file $start_ost_idx
6866
6867         file=$DIR/$tdir/$tfile-4
6868         cmd="$LFS setstripe"
6869         cmd+=" -o $(exclude_items_from_list $ost_indices $start_ost_idx)"
6870         cmd+=" -i $start_ost_idx $file"
6871         echo -e "\n$cmd"
6872         eval $cmd && error "index $start_ost_idx should be in $ost_indices"
6873
6874         # 5. Specifying OST indices for directory should succeed.
6875         local dir=$DIR/$tdir/$tdir
6876         mkdir $dir || error "mkdir $dir failed"
6877         cmd="$LFS setstripe -o $ost_indices $dir"
6878         if [ "$MDS1_VERSION" -gt $(version_code 2.11.53) ] &&
6879                 [ "$CLIENT_VERSION" -gt $(version_code 2.11.53) ]; then
6880                 echo -e "\n$cmd"
6881                 eval $cmd || error "unable to specify OST indices on directory"
6882         else
6883                 echo "need MDS+client version at least 2.11.53"
6884         fi
6885 }
6886 run_test 82a "specify OSTs for file (succeed) or directory (succeed)"
6887
6888 # Test 82b is run to ensure that if the user supplies a pool with a specific
6889 # stripe layout that it behaves proprerly. It should fail in the case that
6890 # the supplied OST index list points to OSTs not contained in the user
6891 # supplied pool.
6892 test_82b() { # LU-4665
6893         [[ "$MDS1_VERSION" -ge $(version_code 2.6.54) ]] ||
6894                 skip "Need MDS version at least 2.6.54"
6895         [[ $OSTCOUNT -ge 4 ]] || skip_env "needs >= 4 OSTs"
6896
6897         stopall
6898
6899         save_ostindex 4
6900
6901         # Format OSTs with random sparse indices.
6902         local i
6903         local index
6904         local ost_indices
6905         local LOV_V1_INSANE_STRIPE_COUNT=65532
6906         for i in $(seq $OSTCOUNT); do
6907                 index=$(((RANDOM * 2) % LOV_V1_INSANE_STRIPE_COUNT))
6908                 ost_indices+=" $index"
6909         done
6910         ost_indices=$(comma_list $ost_indices)
6911
6912         stack_trap "restore_ostindex" EXIT
6913         echo -e "\nFormat $OSTCOUNT OSTs with sparse indices $ost_indices"
6914         OST_INDEX_LIST=[$ost_indices] formatall
6915
6916         # Setup Lustre filesystem.
6917         start_mgsmds || error "start_mgsmds failed"
6918         for i in $(seq $OSTCOUNT); do
6919                 start ost$i $(ostdevname $i) $OST_MOUNT_OPTS ||
6920                         error "start ost$i failed"
6921         done
6922
6923         mount_client $MOUNT || error "mount client $MOUNT failed"
6924
6925         wait_osts_up
6926         $LFS df $MOUNT
6927         check_lfs_df_ret_val $? || error "$LFS df $MOUNT failed"
6928         mkdir $DIR/$tdir || error "mkdir $DIR/$tdir failed"
6929
6930         # Create a new pool and add OSTs into it.
6931         local ost_pool=$FSNAME.$TESTNAME
6932         create_pool $ost_pool || error "create OST pool $ost_pool failed"
6933
6934         local ost_idx_in_list=${ost_indices##*,}
6935         local ost_idx_in_pool=$(exclude_items_from_list $ost_indices \
6936                                 $ost_idx_in_list)
6937
6938         local ost_targets="$FSNAME-OST["
6939         for i in ${ost_idx_in_pool//,/ }; do
6940                 ost_targets=$ost_targets$(printf "%04x," $i)
6941         done
6942         ost_targets="${ost_targets%,}]"
6943
6944         local ost_targets_uuid=$(for i in ${ost_idx_in_pool//,/ }; \
6945                                  do printf "$FSNAME-OST%04x_UUID\n" $i; done |
6946                                  sort -u | tr '\n' ' ')
6947
6948         local cmd="$LCTL pool_add $ost_pool $ost_targets"
6949         do_facet mgs $cmd || error "$cmd failed"
6950         wait_update $HOSTNAME "$LCTL get_param -n lov.$FSNAME-*.pools.$TESTNAME|
6951                                sort -u | tr '\n' ' ' " "$ost_targets_uuid" ||
6952                                         error "wait_update $ost_pool failed"
6953         wait_update_facet $SINGLEMDS "$LCTL pool_list $ost_pool | wc -l" 4 ||
6954                                 error "wait_update pool_list $ost_pool failed"
6955
6956         # If [--pool|-p <pool_name>] is set with [--ost-list|-o <ost_indices>],
6957         # then the OSTs must be the members of the pool.
6958         local file=$DIR/$tdir/$tfile
6959         cmd="$LFS setstripe -p $ost_pool -o $ost_idx_in_list $file"
6960         echo -e "\n$cmd"
6961         eval $cmd && error "OST with index $ost_idx_in_list should be" \
6962                            "in OST pool $ost_pool"
6963
6964         # Only select OST $ost_idx_in_list from $ost_pool for file.
6965         ost_idx_in_list=${ost_idx_in_pool#*,}
6966         cmd="$LFS setstripe -p $ost_pool -o $ost_idx_in_list $file"
6967         echo -e "\n$cmd"
6968         eval $cmd || error "$cmd failed"
6969         cmd="$LFS getstripe $file"
6970         echo -e "\n$cmd"
6971         eval $cmd || error "$cmd failed"
6972         check_stripe_count $file 2
6973         check_obdidx $file $ost_idx_in_list
6974         dd if=/dev/urandom of=$file count=1 bs=1M > /dev/null 2>&1 ||
6975                 error "write $file failed"
6976 }
6977 run_test 82b "specify OSTs for file with --pool and --ost-list options"
6978
6979 test_83() {
6980         [[ "$OST1_VERSION" -ge $(version_code 2.6.91) ]] ||
6981                 skip "Need OST version at least 2.6.91"
6982         if [ "$ost1_FSTYPE" != ldiskfs ]; then
6983                 skip "ldiskfs only test"
6984         fi
6985
6986         local dev
6987         local ostmnt
6988         local fstype
6989         local mnt_opts
6990
6991         dev=$(ostdevname 1)
6992         ostmnt=$(facet_mntpt ost1)
6993
6994         # Mount the OST as an ldiskfs filesystem.
6995         log "mount the OST $dev as a $ost1_FSTYPE filesystem"
6996         add ost1 $(mkfs_opts ost1 $dev) $FSTYPE_OPT \
6997                 --reformat $dev > /dev/null ||
6998                 error "format ost1 error"
6999
7000         if ! test -b $dev; then
7001                 mnt_opts=$(csa_add "$OST_MOUNT_FS_OPTS" -o loop)
7002         fi
7003         echo "mnt_opts $mnt_opts"
7004         do_facet ost1 mount -t "$ost1_FSTYPE" $dev \
7005                 $ostmnt $mnt_opts
7006         # Run llverfs on the mounted ldiskfs filesystem.
7007         # It is needed to get ENOSPACE.
7008         log "run llverfs in partial mode on the OST $ost1_FSTYPE $ostmnt"
7009         do_rpc_nodes $(facet_host ost1) run_llverfs $ostmnt -vpl \
7010                 "no" || error "run_llverfs error on $ost1_FSTYPE"
7011
7012         # Unmount the OST.
7013         log "unmount the OST $dev"
7014         stop ost1
7015
7016         # Delete file IO_scrub. Later osd_scrub_setup will try to
7017         # create "IO_scrub" but will get ENOSPACE.
7018         writeconf_all
7019         echo "start ost1 service on `facet_active_host ost1`"
7020         start ost1 `ostdevname 1` $OST_MOUNT_OPTS
7021
7022         local err
7023         err=$(do_facet ost1 dmesg | grep "VFS: Busy inodes after unmount of")
7024         echo "string err $err"
7025         [ -z "$err" ] || error $err
7026         reformat_and_config
7027 }
7028 run_test 83 "ENOSPACE on OST doesn't cause message VFS: \
7029 Busy inodes after unmount ..."
7030
7031 test_84() {
7032         local facet=$SINGLEMDS
7033         local num=$(echo $facet | tr -d "mds")
7034         local dev=$(mdsdevname $num)
7035         local time_min=$(recovery_time_min)
7036         local recovery_duration
7037         local completed_clients
7038         local correct_clients
7039         local wrap_up=5
7040
7041         echo "start mds service on $(facet_active_host $facet)"
7042         start_mds \
7043         "-o recovery_time_hard=$time_min,recovery_time_soft=$time_min" $@ ||
7044                 error "start MDS failed"
7045
7046         start_ost || error "start OST0000 failed"
7047         wait_osc_import_state mds ost1 FULL
7048         start_ost2 || error "start OST0001 failed"
7049         wait_osc_import_state mds ost2 FULL
7050
7051         echo "recovery_time=$time_min, timeout=$TIMEOUT, wrap_up=$wrap_up"
7052
7053         mount_client $MOUNT1 || error "mount $MOUNT1 failed"
7054         mount_client $MOUNT2 || error "mount $MOUNT2 failed"
7055         # make sure new superblock labels are sync'd before disabling writes
7056         sync_all_data
7057         sleep 5
7058
7059         replay_barrier $SINGLEMDS
7060         createmany -o $DIR1/$tfile-%d 1000
7061
7062         # We need to catch the end of recovery window to extend it.
7063         # Skip 5 requests and add delay to request handling.
7064         #define OBD_FAIL_TGT_REPLAY_DELAY  0x709 | FAIL_SKIP
7065         do_facet $SINGLEMDS "lctl set_param fail_loc=0x20000709 fail_val=5"
7066
7067         facet_failover --fsck $SINGLEMDS || error "failover: $?"
7068         client_up
7069
7070         echo "recovery status"
7071         do_facet $SINGLEMDS \
7072                 "$LCTL get_param -n mdt.$FSNAME-MDT0000.recovery_status"
7073
7074         recovery_duration=$(do_facet $SINGLEMDS \
7075                 "$LCTL get_param -n mdt.$FSNAME-MDT0000.recovery_status" |
7076                 awk '/recovery_duration/ { print $2 }')
7077         (( $recovery_duration > $time_min + $wrap_up )) &&
7078                 error "recovery_duration > recovery_time_hard + wrap up"
7079         completed_clients=$(do_facet $SINGLEMDS \
7080                 "$LCTL get_param -n mdt.$FSNAME-MDT0000.recovery_status" |
7081                 awk '/completed_clients/ { print $2 }')
7082
7083         correct_clients="$MDSCOUNT/$((MDSCOUNT+1))"
7084         [ "$completed_clients" = "${correct_clients}" ] ||
7085                 error "$completed_clients != $correct_clients"
7086
7087         do_facet $SINGLEMDS "lctl set_param fail_loc=0"
7088         umount_client $MOUNT1
7089         umount_client $MOUNT2
7090
7091         stop_ost
7092         stop_ost2
7093         stop_mds
7094 }
7095 run_test 84 "check recovery_hard_time"
7096
7097 test_85() {
7098         [[ "$OST1_VERSION" -ge $(version_code 2.7.55) ]] ||
7099                 skip "Need OST version at least 2.7.55"
7100 ##define OBD_FAIL_OSD_OST_EA_FID_SET 0x197
7101         do_facet ost1 "lctl set_param fail_loc=0x197"
7102         start_ost
7103         stop_ost
7104 }
7105 run_test 85 "osd_ost init: fail ea_fid_set"
7106
7107 cleanup_86() {
7108         trap 0
7109
7110         # ost1 has already registered to the MGS before the reformat.
7111         # So after reformatting it with option "-G", it could not be
7112         # mounted to the MGS. Cleanup the system for subsequent tests.
7113         reformat_and_config
7114 }
7115
7116 test_86() {
7117         [ "$ost1_FSTYPE" = zfs ] &&
7118                 skip "LU-6442: no such mkfs params for ZFS OSTs"
7119         [[ "$MDS1_VERSION" -ge $(version_code 2.7.56) ]] ||
7120                 skip "Need server version newer than 2.7.55"
7121
7122         local NEWSIZE=1024
7123         local OLDSIZE=$(do_facet ost1 "$DEBUGFS -c -R stats $(ostdevname 1)" |
7124                 awk '/Flex block group size: / { print $NF; exit; }')
7125
7126         [ "$OLDSIZE" == "$NEWSIZE" ] && skip "$NEWSIZE groups already"
7127
7128         local opts=" -O flex_bg -G $NEWSIZE"
7129         opts=$(OST_FS_MKFS_OPTS+="$opts" mkfs_opts ost1 $(ostdevname 1))
7130         opts+=" --reformat $(ostdevname 1) $(ostvdevname 1)"
7131         echo "params: $opts"
7132
7133         trap cleanup_86 EXIT ERR
7134
7135         stopall
7136         add ost1 $opts || error "add ost1 failed with new params"
7137
7138         local FOUNDSIZE=$(do_facet ost1 "$DEBUGFS -c -R stats $(ostdevname 1)" |
7139                 awk '/Flex block group size: / { print $NF; exit; }')
7140
7141         [[ $FOUNDSIZE == $NEWSIZE ]] ||
7142                 error "Flex block group size: $FOUNDSIZE, expected: $NEWSIZE"
7143
7144         cleanup_86
7145 }
7146 run_test 86 "Replacing mkfs.lustre -G option"
7147
7148 test_87() { #LU-6544
7149         [[ "$MDS1_VERSION" -ge $(version_code 2.9.51) ]] ||
7150                 skip "Need MDS version at least 2.9.51"
7151         [[ "$mds1_FSTYPE" != ldiskfs ]] &&
7152                 skip "ldiskfs only test"
7153         [[ $OSTCOUNT -gt 59 ]] &&
7154                 skip "Ignore wide striping situation"
7155         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
7156
7157         local mdsdev=$(mdsdevname 1)
7158         local mdsvdev=$(mdsvdevname 1)
7159         local file=$DIR/$tfile
7160         local mntpt=$(facet_mntpt $SINGLEMDS)
7161         local used_xattr_blk=0
7162         local inode_size=${1:-1024}
7163         local left_size=0
7164         local xtest="trusted.test"
7165         local value
7166         local orig
7167         local i
7168         local stripe_cnt=$(($OSTCOUNT + 2))
7169
7170         #Please see ldiskfs_make_lustre() for MDT inode size calculation
7171         if [ $stripe_cnt -gt 16 ]; then
7172                 inode_size=2048
7173         fi
7174         left_size=$(expr $inode_size - \
7175                         156 - \
7176                         32 - \
7177                         32 - 40 \* 3 - 32 \* 3 - $stripe_cnt \* 24 - 16 - 3 -  \
7178                         24 - 16 - 3 - \
7179                         24 - 18 - $(expr length $tfile) - 16 - 4)
7180         if [ $left_size -le 0 ]; then
7181                 echo "No space($left_size) is expected in inode."
7182                 echo "Try 1-byte xattr instead to verify this."
7183                 left_size=1
7184         else
7185                 echo "Estimate: at most $left_size-byte space left in inode."
7186         fi
7187
7188         unload_modules
7189         reformat
7190
7191         if ! combined_mgs_mds ; then
7192                 start_mgs
7193         fi
7194
7195         add mds1 $(mkfs_opts mds1 ${mdsdev}) --stripe-count-hint=$stripe_cnt \
7196                 --reformat $mdsdev $mdsvdev || error "add mds1 failed"
7197         start_mdt 1 > /dev/null || error "start mdt1 failed"
7198         for i in $(seq $OSTCOUNT); do
7199                 start ost$i $(ostdevname $i) $OST_MOUNT_OPTS > /dev/null ||
7200                         error "start ost$i failed"
7201         done
7202         mount_client $MOUNT > /dev/null || error "mount client $MOUNT failed"
7203         check_mount || error "check client $MOUNT failed"
7204
7205         #set xattr
7206         $LFS setstripe -E 1M -S 1M -c 1 -E 64M -c 1 -E -1 -c -1 $file ||
7207                 error "Create file with 3 components failed"
7208         $TRUNCATE $file $((1024*1024*64+1)) || error "truncate file failed"
7209         i=$($LFS getstripe -I3 -c $file) || error "get 3rd stripe count failed"
7210         if [ $i -ne $OSTCOUNT ]; then
7211                 left_size=$(expr $left_size + $(expr $OSTCOUNT - $i) \* 24)
7212                 echo -n "Since only $i out $OSTCOUNT OSTs are used, "
7213                 echo -n "the expected left space is changed to "
7214                 echo "$left_size bytes at most."
7215         fi
7216         value=$(generate_string $left_size)
7217         setfattr -n $xtest -v $value $file
7218         orig=$(get_xattr_value $xtest $file)
7219         [[ "$orig" != "$value" ]] && error "$xtest changed"
7220
7221         #Verify if inode has some expected space left
7222         umount $MOUNT > /dev/null || error "umount $MOUNT failed"
7223         stop_mdt 1 > /dev/null || error "stop mdt1 failed"
7224         mount_ldiskfs $SINGLEMDS || error "mount -t ldiskfs $SINGLEMDS failed"
7225
7226         do_facet $SINGLEMDS ls -sal $mntpt/ROOT/$tfile
7227         used_xattr_blk=$(do_facet $SINGLEMDS ls -s $mntpt/ROOT/$tfile |
7228                         awk '{ print $1 }')
7229         [[ $used_xattr_blk -eq 0 ]] &&
7230                 error "Please check MDS inode size calculation: \
7231                        more than $left_size-byte space left in inode."
7232         echo "Verified: at most $left_size-byte space left in inode."
7233
7234         unmount_ldiskfs $SINGLEMDS
7235
7236         for i in $(seq $OSTCOUNT); do
7237                 stop ost$i -f || error "stop ost$i failed"
7238         done
7239 }
7240 run_test 87 "check if MDT inode can hold EAs with N stripes properly"
7241
7242 test_88() {
7243         [ "$mds1_FSTYPE" == zfs ] &&
7244                 skip "LU-6662: no implementation for ZFS"
7245
7246         load_modules
7247
7248         add mds1 $(mkfs_opts mds1 $(mdsdevname 1)) \
7249                 --reformat $(mdsdevname 1) || error "add mds1 failed"
7250
7251         do_facet mds1 "$TUNEFS $(mdsdevname 1) |
7252                 grep -e \".*opts:.*errors=remount-ro.*\"" ||
7253                 error "default mount options is missing"
7254
7255         add mds1 $(mkfs_opts mds1 $(mdsdevname 1)) \
7256                 --mountfsoptions="user_xattr,errors=panic" \
7257                 --reformat $(mdsdevname 1) || error "add mds1 failed"
7258
7259         do_facet mds1 "$TUNEFS $(mdsdevname 1) |
7260                 grep -e \".*opts:.*errors=panic.*\"" ||
7261                 error "user can't override default mount options"
7262 }
7263 run_test 88 "check the default mount options can be overridden"
7264
7265 test_89() { # LU-7131
7266         [[ "$MDS1_VERSION" -ge $(version_code 2.9.54) ]] ||
7267                 skip "Need MDT version at least 2.9.54"
7268
7269         local key=failover.node
7270         local val1=192.0.2.254@tcp0 # Reserved IPs, see RFC 5735
7271         local val2=192.0.2.255@tcp0
7272         local mdsdev=$(mdsdevname 1)
7273         local params
7274
7275         stopall
7276
7277         if [[ "$mds1_FSTYPE" == zfs ]]; then
7278                 import_zpool mds1 || return ${PIPESTATUS[0]}
7279         fi
7280
7281         # Check that parameters are added correctly
7282         echo "tunefs --param $key=$val1"
7283         do_facet mds1 "$TUNEFS --param $key=$val1 $mdsdev >/dev/null" ||
7284                 error "tunefs --param $key=$val1 failed"
7285         params=$(do_facet mds1 $TUNEFS --dryrun $mdsdev) ||
7286                 error "tunefs --dryrun failed"
7287         params=${params##*Parameters:}
7288         params=${params%%exiting*}
7289         [ $(echo $params | tr ' ' '\n' | grep -c $key=$val1) = "1" ] ||
7290                 error "on-disk parameter not added correctly via tunefs"
7291
7292         # Check that parameters replace existing instances when added
7293         echo "tunefs --param $key=$val2"
7294         do_facet mds1 "$TUNEFS --param $key=$val2 $mdsdev >/dev/null" ||
7295                 error "tunefs --param $key=$val2 failed"
7296         params=$(do_facet mds1 $TUNEFS --dryrun $mdsdev) ||
7297                 error "tunefs --dryrun failed"
7298         params=${params##*Parameters:}
7299         params=${params%%exiting*}
7300         [ $(echo $params | tr ' ' '\n' | grep -c $key=) = "1" ] ||
7301                 error "on-disk parameter not replaced via tunefs"
7302         [ $(echo $params | tr ' ' '\n' | grep -c $key=$val2) = "1" ] ||
7303                 error "on-disk parameter not replaced correctly via tunefs"
7304
7305         # Check that a parameter is erased properly
7306         echo "tunefs --erase-param $key"
7307         do_facet mds1 "$TUNEFS --erase-param $key $mdsdev >/dev/null" ||
7308                 error "tunefs --erase-param $key failed"
7309         params=$(do_facet mds1 $TUNEFS --dryrun $mdsdev) ||
7310                 error "tunefs --dryrun failed"
7311         params=${params##*Parameters:}
7312         params=${params%%exiting*}
7313         [ $(echo $params | tr ' ' '\n' | grep -c $key=) = "0" ] ||
7314                 error "on-disk parameter not erased correctly via tunefs"
7315
7316         # Check that all the parameters are erased
7317         do_facet mds1 "$TUNEFS --param $key=$val1 $mdsdev >/dev/null" ||
7318                 error "tunefs --param $key=$val1 failed"
7319         echo "tunefs --erase-params"
7320         do_facet mds1 "$TUNEFS --erase-params $mdsdev >/dev/null" ||
7321                 error "tunefs --erase-params failed"
7322         params=$(do_facet mds1 $TUNEFS --dryrun $mdsdev) ||
7323                 error "tunefs --dryrun failed"
7324         params=${params##*Parameters:}
7325         params=${params%%exiting*}
7326         params=$(echo $params | tr ' ' '\n')
7327         [ -z "$params" ] ||
7328                 error "all on-disk parameters not erased correctly via tunefs $params"
7329
7330         # Check the order of options --erase-params and --param
7331         echo "tunefs --param $key=$val1 --erase-params"
7332         do_facet mds1 \
7333                 "$TUNEFS --param $key=$val1 --erase-params $mdsdev >/dev/null"||
7334                 error "tunefs --param $key=$val1 --erase-params failed"
7335         params=$(do_facet mds1 $TUNEFS --dryrun $mdsdev) ||
7336                 error "tunefs --dryrun failed"
7337         params=${params##*Parameters:}
7338         params=${params%%exiting*}
7339         [ $(echo $params | tr ' ' '\n') == "$key=$val1" ] ||
7340                 error "on-disk param not added correctly with --erase-params"
7341
7342         reformat_and_config
7343 }
7344 run_test 89 "check tunefs --param and --erase-param{s} options"
7345
7346 # $1 test directory
7347 # $2 (optional) value of max_mod_rpcs_in_flight to set
7348 check_max_mod_rpcs_in_flight() {
7349         local dir="$1"
7350         local mmr="$2"
7351         local idx
7352         local facet
7353         local tmp
7354         local i
7355
7356         idx=$(printf "%04x" $($LFS getdirstripe -i $dir))
7357         facet="mds$((0x$idx + 1))"
7358
7359         if [ -z "$mmr" ]; then
7360                 # get value of max_mod_rcps_in_flight
7361                 mmr=$($LCTL get_param -n \
7362                         mdc.$FSNAME-MDT$idx-mdc-*.max_mod_rpcs_in_flight) ||
7363                         error "Unable to get max_mod_rpcs_in_flight"
7364                 echo "max_mod_rcps_in_flight is $mmr"
7365         else
7366                 # set value of max_mod_rpcs_in_flight
7367                 $LCTL set_param \
7368                     mdc.$FSNAME-MDT$idx-mdc-*.max_mod_rpcs_in_flight=$mmr ||
7369                         error "Unable to set max_mod_rpcs_in_flight to $mmr"
7370                 echo "max_mod_rpcs_in_flight set to $mmr"
7371         fi
7372
7373         # create mmr+1 files
7374         echo "creating $((mmr + 1)) files ..."
7375         umask 0022
7376         for i in $(seq $((mmr + 1))); do
7377                 touch $dir/file-$i
7378         done
7379
7380         ### part 1 ###
7381
7382         # consumes mmr-1 modify RPC slots
7383         #define OBD_FAIL_MDS_REINT_MULTI_NET     0x159
7384         # drop requests on MDT so that RPC slots are consumed
7385         # during all the request resend interval
7386         do_facet $facet "$LCTL set_param fail_loc=0x159"
7387         echo "launch $((mmr - 1)) chmod in parallel ..."
7388         for i in $(seq $((mmr - 1))); do
7389                 chmod 0600 $dir/file-$i &
7390         done
7391         sleep 1
7392
7393         # send one additional modify RPC
7394         do_facet $facet "$LCTL set_param fail_loc=0"
7395         echo "launch 1 additional chmod in parallel ..."
7396         chmod 0600 $dir/file-$mmr &
7397         sleep 1
7398
7399         # check this additional modify RPC get a modify RPC slot
7400         # and succeed its operation
7401         checkstat -vp 0600 $dir/file-$mmr ||
7402                 error "Unable to send $mmr modify RPCs in parallel"
7403         wait
7404
7405         ### part 2 ###
7406
7407         # consumes mmr modify RPC slots
7408         #define OBD_FAIL_MDS_REINT_MULTI_NET     0x159
7409         # drop requests on MDT so that RPC slots are consumed
7410         # during all the request resend interval
7411         do_facet $facet "$LCTL set_param fail_loc=0x159"
7412         echo "launch $mmr chmod in parallel ..."
7413         for i in $(seq $mmr); do
7414                 chmod 0666 $dir/file-$i &
7415         done
7416         sleep 1
7417
7418         # send one additional modify RPC
7419         do_facet $facet "$LCTL set_param fail_loc=0"
7420         echo "launch 1 additional chmod in parallel ..."
7421         chmod 0666 $dir/file-$((mmr + 1)) &
7422         sleep 1
7423
7424         # check this additional modify RPC blocked getting a modify RPC slot
7425         checkstat -vp 0644 $dir/file-$((mmr + 1)) ||
7426                 error "Unexpectedly send $(($mmr + 1)) modify RPCs in parallel"
7427         wait
7428 }
7429
7430 get_mdt_max_mod_rpcs_in_flight_val() {
7431         local max_mrif
7432         local facet="$1"
7433
7434         # It will be enough to get one value from one MDT
7435         max_mrif=$(do_facet $facet \
7436                 "$LCTL get_param -n \
7437                 mdt.$FSNAME-MDT*.max_mod_rpcs_in_flight | head -n 1")
7438         if [[ $max_mrif ]]; then
7439                 echo $max_mrif
7440         else
7441                 max_mrif=$(do_facet $facet \
7442                 cat /sys/module/mdt/parameters/max_mod_rpcs_per_client)
7443                 echo $max_mrif
7444         fi
7445 }
7446
7447 set_mdt_max_mod_rpcs_in_flight() {
7448         local lctl_op
7449         local max_mrif="$1"
7450         local facet="$2"
7451
7452         lctl_op=$($LCTL get_param \
7453                 mdt.*.max_mod_rpcs_in_flight)
7454         if [[ $lctl_op ]]; then
7455                 do_facet $facet \
7456                         "$LCTL set_param \
7457                         mdt.$FSNAME-MDT*.max_mod_rpcs_in_flight=$max_mrif"
7458         else
7459                 do_facet $facet \
7460                         "echo $max_mrif > \
7461                         /sys/module/mdt/parameters/max_mod_rpcs_per_client"
7462                 echo "the deprecated max_mod_rpcs_per_client \
7463                                 parameter was involved"
7464         fi
7465 }
7466
7467 test_90a() {
7468         setup
7469
7470         [[ $($LCTL get_param mdc.*.import |
7471              grep "connect_flags:.*multi_mod_rpc") ]] ||
7472                 skip "Need MDC with 'multi_mod_rpcs' feature"
7473
7474         # check default value
7475         $LFS mkdir -c1 $DIR/$tdir || error "mkdir $DIR/$tdir failed"
7476         check_max_mod_rpcs_in_flight $DIR/$tdir
7477
7478         cleanup
7479 }
7480 run_test 90a "check max_mod_rpcs_in_flight is enforced"
7481
7482 test_90b() {
7483         local idx
7484         local facet
7485         local tmp
7486         local mmrpc
7487
7488         setup
7489
7490         [[ $($LCTL get_param mdc.*.import |
7491              grep "connect_flags:.*multi_mod_rpc") ]] ||
7492                 skip "Need MDC with 'multi_mod_rpcs' feature"
7493
7494         ### test 1.
7495         # update max_mod_rpcs_in_flight
7496         $LFS mkdir -c1 $DIR/${tdir}1 || error "mkdir $DIR/${tdir}1 failed"
7497         check_max_mod_rpcs_in_flight $DIR/${tdir}1 1
7498
7499         ### test 2.
7500         # check client is able to send multiple modify RPCs in paralell
7501         tmp=$($LCTL get_param -n mdc.$FSNAME-MDT*-mdc-*.import |
7502                 grep -c "multi_mod_rpcs")
7503         if [ "$tmp" -ne $MDSCOUNT ]; then
7504                 cleanup
7505                 skip "Client not able to send multiple modify RPCs in parallel"
7506         fi
7507
7508         # update max_mod_rpcs_in_flight
7509         $LFS mkdir -c1 $DIR/${tdir}2 || error "mkdir $DIR/${tdir}2 failed"
7510         check_max_mod_rpcs_in_flight $DIR/${tdir}2 5
7511
7512         ### test 3.
7513         $LFS mkdir -c1 $DIR/${tdir}3 || error "mkdir $DIR/${tdir}3 failed"
7514         idx=$(printf "%04x" $($LFS getdirstripe -i $DIR/${tdir}3))
7515         facet="mds$((0x$idx + 1))"
7516
7517         mmrpc=$(get_mdt_max_mod_rpcs_in_flight_val $facet)
7518         echo "mdt_max_mod_rpcs_in_flight is $mmrpc"
7519         # update max_mod_rpcs_in_flight
7520         umount_client $MOUNT
7521         set_mdt_max_mod_rpcs_in_flight 16 $facet
7522         mount_client $MOUNT
7523         $LCTL set_param mdc.$FSNAME-MDT$idx-mdc-*.max_rpcs_in_flight=17
7524         check_max_mod_rpcs_in_flight $DIR/${tdir}3 16
7525
7526         # restore MDT max_mod_rpcs_in_flight initial value
7527         set_mdt_max_mod_rpcs_in_flight $mmrpc $facet
7528
7529         rm -rf $DIR/${tdir}?
7530         cleanup
7531 }
7532 run_test 90b "check max_mod_rpcs_in_flight is enforced after update"
7533
7534 save_params_90c() {
7535         # get max_rpcs_in_flight value
7536         mrif_90c=$($LCTL get_param -n \
7537                    mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight)
7538         echo "max_rpcs_in_flight is $mrif_90c"
7539
7540         # get MDC max_mod_rpcs_in_flight value
7541         mmrif_90c=$($LCTL get_param -n \
7542                     mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight)
7543         echo "MDC max_mod_rpcs_in_flight is $mmrif_90c"
7544
7545         # get MDT max_mod_rpcs_in_flight value
7546         mmrpc_90c=$(get_mdt_max_mod_rpcs_in_flight_val "mds1")
7547         echo "mdt_max_mod_rpcs_in_flight is $mmrpc_90c"
7548 }
7549
7550 restore_params_90c() {
7551         trap 0
7552
7553         # restore max_rpcs_in_flight value
7554         do_facet mgs $LCTL set_param -P \
7555                 mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight=$mrif_90c
7556
7557         # restore max_mod_rpcs_in_flight value
7558         do_facet mgs $LCTL set_param -P \
7559                 mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight=$mmrif_90c
7560
7561         # restore MDT max_mod_rpcs_in_flight value
7562         set_mdt_max_mod_rpcs_in_flight $mmrpc_90c "mds1"
7563 }
7564
7565 test_90c() {
7566         local tmp
7567
7568         setup
7569
7570         [[ $($LCTL get_param mdc.*.import |
7571              grep "connect_flags:.*multi_mod_rpc") ]] ||
7572                 skip "Need MDC with 'multi_mod_rpcs' feature"
7573
7574         # check client is able to send multiple modify RPCs in paralell
7575         tmp=$($LCTL get_param -n mdc.$FSNAME-MDT*-mdc-*.import |
7576                 grep -c "multi_mod_rpcs")
7577         if [ "$tmp" -ne $MDSCOUNT ]; then
7578                 cleanup
7579                 skip "Client not able to send multiple modify RPCs in parallel"
7580         fi
7581
7582         save_params_90c
7583         stack_trap restore_params_90c
7584
7585         # testcase 1
7586         # attempt to set max_mod_rpcs_in_flight to max_rpcs_in_flight value
7587         # prerequisite: set MDT max_mod_rpcs_in_flight to
7588         # max_rpcs_in_flight value
7589         set_mdt_max_mod_rpcs_in_flight $mrif_90c "mds1"
7590
7591         # if max_mod_rpcs_in_flight is set to be equal to or larger than
7592         # max_rpcs_in_flight, then max_rpcs_in_flight will be increased
7593         if [[ "$CLIENT_VERSION" -ge $(version_code 2.13.53) ]]; then
7594                 $LCTL set_param \
7595                 mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight=$mrif_90c ||
7596                         error "set max_mod_rpcs_in_flight to $mrif_90c failed"
7597
7598                 local new_mrif=$($LCTL get_param -n \
7599                                  mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight)
7600                 ((new_mrif == mrif_90c + 1)) ||
7601                         error "max_rpcs_in_flight was not increased"
7602         fi
7603
7604         umount_client $MOUNT
7605         set_mdt_max_mod_rpcs_in_flight $mmrpc_90c "mds1"
7606         mount_client $MOUNT
7607
7608         # testcase 2
7609         # attempt to set max_mod_rpcs_in_flight to MDT max_mod_rpcs_in_flight+1
7610         # prerequisite: set max_rpcs_in_flight to MDT max_mod_rpcs_in_flight+2
7611         $LCTL set_param \
7612                 mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight=$((mmrpc_90c + 2))
7613
7614         $LCTL set_param \
7615         mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight=$((mmrpc_90c + 1)) &&
7616         error "set max_mod_rpcs_in_flight to $((mmrpc_90c + 1)) should fail"
7617
7618         # testcase 3
7619         # attempt to set max_mod_rpcs_in_flight permanently
7620         do_facet mgs $LCTL set_param -P \
7621                 mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight=$mrif_90c
7622
7623         do_facet mgs $LCTL set_param -P \
7624                 mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight=$mrif_90c
7625
7626         remount_client $MOUNT
7627
7628         wait_update_facet --verbose client "$LCTL get_param -n \
7629                 mdc.$FSNAME-MDT0000-mdc-*.max_rpcs_in_flight" \
7630                 "$((mrif_90c + 1))" ||
7631                 error "expected '$((mrif_90c + 1))' for max_rpcs_in_flight"
7632
7633         wait_update_facet --verbose client "$LCTL get_param -n \
7634                 mdc.$FSNAME-MDT0000-mdc-*.max_mod_rpcs_in_flight" \
7635                 "$mrif_90c" ||
7636                 error "expected '$mrif_90c' for max_mod_rpcs_in_flight"
7637
7638         restore_params_90c
7639         cleanup
7640 }
7641 run_test 90c "check max_mod_rpcs_in_flight update limits"
7642
7643 test_90d() {
7644         local idx
7645         local facet
7646         local mmr
7647         local i
7648         local pid
7649
7650         setup
7651
7652         [[ $($LCTL get_param mdc.*.import |
7653              grep "connect_flags:.*multi_mod_rpc") ]] ||
7654                 skip "Need MDC with 'multi_mod_rpcs' feature"
7655
7656         $LFS mkdir -c1 $DIR/$tdir || error "mkdir $DIR/$tdir failed"
7657         idx=$(printf "%04x" $($LFS getdirstripe -i $DIR/$tdir))
7658         facet="mds$((0x$idx + 1))"
7659
7660         # check client version supports multislots
7661         tmp=$($LCTL get_param -N \
7662                 mdc.$FSNAME-MDT$idx-mdc-*.max_mod_rpcs_in_flight)
7663         if [ -z "$tmp" ]; then
7664                 cleanup
7665                 skip "Client does not support multiple modify RPCs in flight"
7666         fi
7667
7668         # get current value of max_mod_rcps_in_flight
7669         mmr=$($LCTL get_param -n \
7670                 mdc.$FSNAME-MDT$idx-mdc-*.max_mod_rpcs_in_flight)
7671         echo "max_mod_rcps_in_flight is $mmr"
7672
7673         # create mmr files
7674         echo "creating $mmr files ..."
7675         umask 0022
7676         for i in $(seq $mmr); do
7677                 touch $DIR/$tdir/file-$i
7678         done
7679
7680         # prepare for close RPC
7681         multiop_bg_pause $DIR/$tdir/file-close O_c
7682         pid=$!
7683
7684         # consumes mmr modify RPC slots
7685         #define OBD_FAIL_MDS_REINT_MULTI_NET     0x159
7686         # drop requests on MDT so that RPC slots are consumed
7687         # during all the request resend interval
7688         do_facet $facet "$LCTL set_param fail_loc=0x159"
7689         echo "launch $mmr chmod in parallel ..."
7690         for i in $(seq $mmr); do
7691                 chmod 0600 $DIR/$tdir/file-$i &
7692         done
7693
7694         # send one additional close RPC
7695         do_facet $facet "$LCTL set_param fail_loc=0"
7696         echo "launch 1 additional close in parallel ..."
7697         kill -USR1 $pid
7698         cancel_lru_locks mdc
7699         sleep 1
7700
7701         # check this additional close RPC get a modify RPC slot
7702         # and multiop process completed
7703         [ -d /proc/$pid ] &&
7704                 error "Unable to send the additional close RPC in parallel"
7705         wait
7706         rm -rf $DIR/$tdir
7707         cleanup
7708 }
7709 run_test 90d "check one close RPC is allowed above max_mod_rpcs_in_flight"
7710
7711 check_uuid_on_ost() {
7712         local nid=$1
7713         do_facet ost1 "$LCTL get_param obdfilter.${FSNAME}*.exports.'$nid'.uuid"
7714 }
7715
7716 check_uuid_on_mdt() {
7717         local nid=$1
7718         do_facet $SINGLEMDS "$LCTL get_param mdt.${mds1_svc}*.exports.'$nid'.uuid"
7719 }
7720
7721 test_91() {
7722         local uuid
7723         local nid
7724         local found
7725
7726         [[ "$OST1_VERSION" -ge $(version_code 2.7.63) ]] ||
7727                 skip "Need OST version at least 2.7.63"
7728         [[ "$MDS1_VERSION" -ge $(version_code 2.7.63) ]] ||
7729                 skip "Need MDT version at least 2.7.63"
7730
7731         start_mds || error "MDS start failed"
7732         start_ost || error "unable to start OST"
7733         mount_client $MOUNT || error "client start failed"
7734         check_mount || error "check_mount failed"
7735
7736         if remote_mds; then
7737                 nid=$($LCTL list_nids | head -1 | sed  "s/\./\\\./g")
7738         else
7739                 nid="0@lo"
7740         fi
7741         uuid=$(get_client_uuid $MOUNT)
7742
7743         echo "list nids on mdt:"
7744         do_facet $SINGLEMDS "$LCTL list_param mdt.${FSNAME}*.exports.*"
7745         echo "uuid from $nid:"
7746         do_facet $SINGLEMDS "$LCTL get_param mdt.${FSNAME}*.exports.'$nid'.uuid"
7747
7748         found=$(check_uuid_on_mdt $nid | grep $uuid)
7749         [ -z "$found" ] && error "can't find $uuid $nid on MDT"
7750         found=$(check_uuid_on_ost $nid | grep $uuid)
7751         [ -z "$found" ] && error "can't find $uuid $nid on OST"
7752
7753         # umount the client so it won't reconnect
7754         manual_umount_client --force || error "failed to umount $?"
7755         # shouldn't disappear on MDS after forced umount
7756         found=$(check_uuid_on_mdt $nid | grep $uuid)
7757         [ -z "$found" ] && error "can't find $uuid $nid"
7758
7759         echo "evict $nid"
7760         do_facet $SINGLEMDS \
7761                 "$LCTL set_param -n mdt.${mds1_svc}.evict_client nid:$nid"
7762         sleep 1 # eviction above is async, give it some time to proceed
7763
7764         found=$(check_uuid_on_mdt $nid | grep $uuid)
7765         [ -n "$found" ] && error "found $uuid $nid on MDT"
7766         found=$(check_uuid_on_ost $nid | grep $uuid)
7767         [ -n "$found" ] && error "found $uuid $nid on OST"
7768
7769         # check it didn't reconnect (being umounted)
7770         sleep $((TIMEOUT+1))
7771         found=$(check_uuid_on_mdt $nid | grep $uuid)
7772         [ -n "$found" ] && error "found $uuid $nid on MDT"
7773         found=$(check_uuid_on_ost $nid | grep $uuid)
7774         [ -n "$found" ] && error "found $uuid $nid on OST"
7775
7776         cleanup
7777 }
7778 run_test 91 "evict-by-nid support"
7779
7780 generate_ldev_conf() {
7781         # generate an ldev.conf file
7782         local ldevconfpath=$1
7783         local fstype=
7784         local fsldevformat=""
7785         rm -f $ldevconfpath
7786
7787         local facets="mgs,$(get_facets OST),$(get_facets MDS)"
7788         for facet in ${facets//,/ }; do
7789                 fsldevformat=""
7790                 fstype=$(facet_fstype $facet)
7791                 [ "$fstype" = zfs ] && fsldevformat="$fstype:"
7792                 local host=$(facet_host $facet)
7793                 local fo="-"
7794                 local varfo=${facet}failover_HOST
7795                 if [ $facet == mgs ] && combined_mgs_mds; then
7796                         varfo=mds1failover_HOST
7797                 fi
7798                 [ -n "${!varfo}" ] && fo=${!varfo}
7799                 local type=$(echo $facet | tr -d "[:digit:]" | \
7800                         tr "[:lower:]" "[:upper:]" | sed s/MDS/MDT/ )
7801                 local num=1
7802                 [ ${facet} == mgs ] ||
7803                         num=$(facet_number $facet)
7804                 printf "%s\t%s\t%s-%s%04x\t%s%s\n" \
7805                         ${host} \
7806                         ${fo} \
7807                         $FSNAME \
7808                         $type \
7809                         $(( num - 1 )) \
7810                         $fsldevformat \
7811                         $(facet_device $facet) >> $ldevconfpath
7812         done
7813
7814         echo "----- $ldevconfpath -----"
7815         cat $ldevconfpath
7816         echo "--- END $ldevconfpath ---"
7817
7818 }
7819
7820 generate_nids() {
7821         # generate a nids file (mapping between hostname to nid)
7822         # looks like we only have the MGS nid available to us
7823         # so just echo that to a file
7824         local nidspath=$1
7825         echo -e "${mgs_HOST}\t${MGSNID}" > $nidspath
7826
7827         echo "----- $nidspath -----"
7828         cat $nidspath
7829         echo "--- END $nidspath ---"
7830 }
7831
7832 compare_ldev_output() {
7833         local ldev_output=$1
7834         local expected_output=$2
7835
7836         sort $expected_output -o $expected_output
7837         sort $ldev_output -o $ldev_output
7838
7839         echo "-- START OF LDEV OUTPUT --"
7840         cat $ldev_output
7841         echo "--- END OF LDEV OUTPUT ---"
7842
7843         echo "-- START OF EXPECTED OUTPUT --"
7844         cat $expected_output
7845         echo "--- END OF EXPECTED OUTPUT ---"
7846
7847         diff $expected_output $ldev_output
7848         return $?
7849 }
7850
7851 test_92() {
7852         if [ -z "$LDEV" ]; then
7853                 error "ldev is missing!"
7854         fi
7855
7856         local LDEVCONFPATH=$TMP/ldev.conf
7857         local NIDSPATH=$TMP/nids
7858
7859         echo "Host is $(hostname)"
7860
7861         generate_ldev_conf $LDEVCONFPATH
7862         generate_nids $NIDSPATH
7863
7864         # echo the mgs nid and compare it to environment variable MGSNID
7865         local facets="$(get_facets OST),$(get_facets MDS),mgs"
7866         for facet in ${facets//,/ }; do
7867                 local host=$(facet_host $facet)
7868                 local output=$($LDEV -c $LDEVCONFPATH -H $host -n $NIDSPATH echo %m)
7869
7870                 echo "-- START OF LDEV OUTPUT --"
7871                 echo -e "$output"
7872                 echo "--- END OF LDEV OUTPUT ---"
7873
7874                 [ -z "$output" ] &&
7875                         error "ldev failed to execute!"
7876
7877                 # need to process multiple lines because of
7878                 # several targets on host
7879                 echo -e $output | awk '{ print $2 }' | while read -r line ; do
7880                         [ "$line" = "$MGSNID" ] ||
7881                                 error "ldev failed mgs nid '$line', \
7882                                         expected '$MGSNID'"
7883                 done
7884         done
7885         rm -f $LDEVCONFPATH $NIDSPATH
7886 }
7887 run_test 92 "ldev returns MGS NID correctly in command substitution"
7888
7889 test_93() {
7890         [ $MDSCOUNT -lt 3 ] && skip "needs >= 3 MDTs"
7891
7892         reformat
7893         #start mgs or mgs/mdt0
7894         if ! combined_mgs_mds ; then
7895                 start_mgs
7896                 start_mdt 1
7897         else
7898                 start_mdt 1
7899         fi
7900
7901         start_ost || error "OST0 start fail"
7902
7903         #define OBD_FAIL_MGS_WRITE_TARGET_DELAY  0x90e
7904         do_facet mgs "$LCTL set_param fail_val=10 fail_loc=0x8000090e"
7905         for num in $(seq 2 $MDSCOUNT); do
7906                 start_mdt $num &
7907         done
7908
7909         mount_client $MOUNT || error "mount client fails"
7910         wait_osc_import_state mds ost FULL
7911         wait_osc_import_ready client ost
7912         check_mount || error "check_mount failed"
7913
7914         cleanup || error "cleanup failed with $?"
7915 }
7916 run_test 93 "register mulitple MDT at the same time"
7917
7918 test_94() {
7919         if [ -z "$LDEV" ]; then
7920                 error "ldev is missing!"
7921         fi
7922
7923         local LDEVCONFPATH=$TMP/ldev.conf
7924         local NIDSPATH=$TMP/nids
7925
7926         generate_ldev_conf $LDEVCONFPATH
7927         generate_nids $NIDSPATH
7928
7929         local LDEV_OUTPUT=$TMP/ldev-output.txt
7930         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME > $LDEV_OUTPUT
7931
7932         # ldev failed, error
7933         if [ $? -ne 0 ]; then
7934                 rm $LDEVCONFPATH $NIDSPATH $LDEV_OUTPUT
7935                 error "ldev failed to execute!"
7936         fi
7937
7938         # expected output
7939         local EXPECTED_OUTPUT=$TMP/ldev-expected.txt
7940
7941         printf "%s-MGS0000\n" $FSNAME > $EXPECTED_OUTPUT
7942
7943         for num in $(seq $MDSCOUNT); do
7944                 printf "%s-MDT%04x\n" $FSNAME $((num - 1)) >> $EXPECTED_OUTPUT
7945         done
7946
7947         for num in $(seq $OSTCOUNT); do
7948                 printf "%s-OST%04x\n" $FSNAME $((num - 1)) >> $EXPECTED_OUTPUT
7949         done
7950
7951         compare_ldev_output $LDEV_OUTPUT $EXPECTED_OUTPUT
7952
7953         if [ $? -ne 0 ]; then
7954                 rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
7955                 error "ldev failed to produce the correct hostlist!"
7956         fi
7957
7958         rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
7959 }
7960 run_test 94 "ldev outputs correct labels for file system name query"
7961
7962 test_95() {
7963         if [ -z "$LDEV" ]; then
7964                 error "ldev is missing!"
7965         fi
7966
7967         local LDEVCONFPATH=$TMP/ldev.conf
7968         local NIDSPATH=$TMP/nids
7969
7970         generate_ldev_conf $LDEVCONFPATH
7971         generate_nids $NIDSPATH
7972
7973         # SUCCESS CASES
7974         # file sys filter
7975         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME &>/dev/null
7976         if [ $? -ne 0 ]; then
7977                 rm $LDEVCONFPATH $NIDSPATH
7978                 error "ldev label filtering w/ -F failed!"
7979         fi
7980
7981         # local filter
7982         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -l  &>/dev/null
7983         if [ $? -ne 0 ]; then
7984                 rm $LDEVCONFPATH $NIDSPATH
7985                 error "ldev label filtering w/ -l failed!"
7986         fi
7987
7988         # foreign filter
7989         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -f &>/dev/null
7990         if [ $? -ne 0 ]; then
7991                 rm $LDEVCONFPATH $NIDSPATH
7992                 error "ldev label filtering w/ -f failed!"
7993         fi
7994
7995         # all filter
7996         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -a &>/dev/null
7997         if [ $? -ne 0 ]; then
7998                 rm $LDEVCONFPATH $NIDSPATH
7999                 error "ldev label filtering w/ -a failed!"
8000         fi
8001
8002         # FAILURE CASES
8003         # all & file sys
8004         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -a -F $FSNAME &>/dev/null
8005         if [ $? -eq 0 ]; then
8006                 rm $LDEVCONFPATH $NIDSPATH
8007                 error "ldev label filtering w/ -a and -F incorrectly succeeded"
8008         fi
8009
8010         # all & foreign
8011         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -a -f &>/dev/null
8012         if [ $? -eq 0 ]; then
8013                 rm $LDEVCONFPATH $NIDSPATH
8014                 error "ldev label filtering w/ -a and -f incorrectly succeeded"
8015         fi
8016
8017         # all & local
8018         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -a -l &>/dev/null
8019         if [ $? -eq 0 ]; then
8020                 rm $LDEVCONFPATH $NIDSPATH
8021                 error "ldev label filtering w/ -a and -l incorrectly succeeded"
8022         fi
8023
8024         # foreign & local
8025         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -f -l &>/dev/null
8026         if [ $? -eq 0 ]; then
8027                 rm $LDEVCONFPATH $NIDSPATH
8028                 error "ldev label filtering w/ -f and -l incorrectly succeeded"
8029         fi
8030
8031         # file sys & local
8032         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME -l &>/dev/null
8033         if [ $? -eq 0 ]; then
8034                 rm $LDEVCONFPATH $NIDSPATH
8035                 error "ldev label filtering w/ -F and -l incorrectly succeeded"
8036         fi
8037
8038         # file sys & foreign
8039         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME -f &>/dev/null
8040         if [ $? -eq 0 ]; then
8041                 rm $LDEVCONFPATH $NIDSPATH
8042                 error "ldev label filtering w/ -F and -f incorrectly succeeded"
8043         fi
8044
8045         rm $LDEVCONFPATH $NIDSPATH
8046 }
8047 run_test 95 "ldev should only allow one label filter"
8048
8049 test_96() {
8050         if [ -z "$LDEV" ]; then
8051                 error "ldev is missing!"
8052         fi
8053
8054         local LDEVCONFPATH=$TMP/ldev.conf
8055         local NIDSPATH=$TMP/nids
8056
8057         generate_ldev_conf $LDEVCONFPATH
8058         generate_nids $NIDSPATH
8059
8060         local LDEV_OUTPUT=$TMP/ldev-output.txt
8061         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -H $mgs_HOST \
8062                 echo %H-%b | \
8063                 awk '{print $2}' > $LDEV_OUTPUT
8064
8065         # ldev failed, error
8066         if [ $? -ne 0 ]; then
8067                 rm $LDEVCONFPATH $NIDSPATH $LDEV_OUTPUT
8068                 error "ldev failed to execute!"
8069         fi
8070
8071         # expected output
8072         local EXPECTED_OUTPUT=$TMP/ldev-expected-output.txt
8073
8074         echo "$mgs_HOST-$(facet_fstype mgs)" > $EXPECTED_OUTPUT
8075
8076         local facets="$(get_facets OST),$(get_facets MDS)"
8077         for facet in ${facets//,/ }; do
8078                 local host=$(facet_host $facet)
8079                 [ "$mgs_HOST" == "$host" ] &&
8080                         echo "$host-$(facet_fstype $facet)" \
8081                         >> $EXPECTED_OUTPUT
8082         done
8083
8084         compare_ldev_output $LDEV_OUTPUT $EXPECTED_OUTPUT
8085
8086         if [ $? -ne 0 ]; then
8087                 rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8088                 error "ldev failed to produce the correct output!"
8089         fi
8090
8091         rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8092 }
8093 run_test 96 "ldev returns hostname and backend fs correctly in command sub"
8094
8095 test_97() {
8096         if [ -z "$LDEV" ]; then
8097                 error "ldev is missing!"
8098         fi
8099
8100         local LDEVCONFPATH=$TMP/ldev.conf
8101         local NIDSPATH=$TMP/nids
8102
8103         generate_ldev_conf $LDEVCONFPATH
8104         generate_nids $NIDSPATH
8105
8106         local LDEV_OUTPUT=$TMP/ldev-output.txt
8107         local EXPECTED_OUTPUT=$TMP/ldev-expected-output.txt
8108
8109         echo -e "\nMDT role"
8110         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME -R mdt > $LDEV_OUTPUT
8111
8112         if [ $? -ne 0 ]; then
8113                 rm $LDEVCONFPATH $NIDSPATH $LDEV_OUTPUT
8114                 error "ldev failed to execute for mdt role!"
8115         fi
8116
8117         for num in $(seq $MDSCOUNT); do
8118                 printf "%s-MDT%04x\n" $FSNAME $((num - 1)) >> $EXPECTED_OUTPUT
8119         done
8120
8121         compare_ldev_output $LDEV_OUTPUT $EXPECTED_OUTPUT
8122
8123         if [ $? -ne 0 ]; then
8124                 rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8125                 error "ldev failed to produce the correct output for mdt role!"
8126         fi
8127
8128         echo -e "\nOST role"
8129         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME -R ost > $LDEV_OUTPUT
8130
8131         if [ $? -ne 0 ]; then
8132                 rm $LDEVCONFPATH $NIDSPATH $LDEV_OUTPUT $EXPECTED_OUTPUT
8133                 error "ldev failed to execute for ost role!"
8134         fi
8135
8136         rm $EXPECTED_OUTPUT
8137         for num in $(seq $OSTCOUNT); do
8138                 printf "%s-OST%04x\n" $FSNAME $((num - 1)) >> $EXPECTED_OUTPUT
8139         done
8140
8141         compare_ldev_output $LDEV_OUTPUT $EXPECTED_OUTPUT
8142
8143         if [ $? -ne 0 ]; then
8144                 rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8145                 error "ldev failed to produce the correct output for ost role!"
8146         fi
8147
8148         echo -e "\nMGS role"
8149         $LDEV -c $LDEVCONFPATH -n $NIDSPATH -F $FSNAME -R mgs > $LDEV_OUTPUT
8150
8151         if [ $? -ne 0 ]; then
8152                 rm $LDEVCONFPATH $NIDSPATH $LDEV_OUTPUT $EXPECTED_OUTPUT
8153                 error "ldev failed to execute for mgs role!"
8154         fi
8155
8156         printf "%s-MGS0000\n" $FSNAME > $EXPECTED_OUTPUT
8157
8158         compare_ldev_output $LDEV_OUTPUT $EXPECTED_OUTPUT
8159
8160         if [ $? -ne 0 ]; then
8161                 rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8162                 error "ldev failed to produce the correct output for mgs role!"
8163         fi
8164
8165         rm $LDEVCONFPATH $NIDSPATH $EXPECTED_OUTPUT $LDEV_OUTPUT
8166 }
8167 run_test 97 "ldev returns correct ouput when querying based on role"
8168
8169 test_98()
8170 {
8171         local mountopt
8172
8173         setup
8174         check_mount || error "mount failed"
8175         mountopt="user_xattr"
8176         for ((x = 1; x <= PAGE_SIZE/11; x++)); do
8177                 mountopt="$mountopt,user_xattr"
8178         done
8179         mount_client $MOUNT remount,$mountopt 2>&1 | grep "too long" ||
8180                 error "Buffer overflow check failed"
8181         cleanup || error "cleanup failed"
8182 }
8183 run_test 98 "Buffer-overflow check while parsing mount_opts"
8184
8185 test_99()
8186 {
8187         [[ "$ost1_FSTYPE" != ldiskfs ]] &&
8188                 skip "ldiskfs only test"
8189         [[ "$OST1_VERSION" -ge $(version_code 2.8.57) ]] ||
8190                 skip "Need OST version at least 2.8.57"
8191
8192         local ost_opts="$(mkfs_opts ost1 $(ostdevname 1)) \
8193                 --reformat $(ostdevname 1) $(ostvdevname 1)"
8194         do_facet ost1 $DEBUGFS -c -R stats `ostdevname 1` | grep "meta_bg" &&
8195                 skip "meta_bg already set"
8196
8197         local opts=ost_opts
8198         if [[ ${!opts} != *mkfsoptions* ]]; then
8199                 eval opts=\"${!opts} \
8200                 --mkfsoptions='\\\"-O ^resize_inode,meta_bg\\\"'\"
8201         else
8202                 local val=${!opts//--mkfsoptions=\\\"/ \
8203                 --mkfsoptions=\\\"-O ^resize_inode,meta_bg }
8204                 eval opts='${val}'
8205         fi
8206
8207         echo "params: $opts"
8208
8209         load_modules
8210         add ost1 $opts || error "add ost1 failed with new params"
8211
8212         do_facet ost1 $DEBUGFS -c -R stats `ostdevname 1` | grep "meta_bg" ||
8213                 error "meta_bg is not set"
8214 }
8215 run_test 99 "Adding meta_bg option"
8216
8217 test_100() {
8218         reformat
8219
8220         start_mgsmds || error "MDS start failed"
8221         start_ost || error "unable to start OST"
8222         mount_client $MOUNT || error "client start failed"
8223         check_mount || error "check_mount failed"
8224
8225         # Desired output
8226         # MGS:
8227         #     0@lo
8228         # $FSNAME-MDT0000:
8229         #     0@lo
8230         # $FSNAME-OST0000:
8231         #     0@lo
8232         do_facet mgs 'lshowmount -v' | awk 'BEGIN {NR == 0; rc=1} /MGS:/ {rc=0}
8233                 END {exit rc}' || error "lshowmount have no output MGS"
8234
8235         do_facet mds1 'lshowmount -v' | awk 'BEGIN {NR == 2; rc=1} /-MDT0000:/
8236                 {rc=0} END {exit rc}' || error "lshowmount have no output MDT0"
8237
8238         do_facet ost1 'lshowmount -v' | awk 'BEGIN {NR == 4; rc=1} /-OST0000:/
8239                 {rc=0} END {exit rc}' || error "lshowmount have no output OST0"
8240
8241         cleanup || error "cleanup failed with $?"
8242 }
8243 run_test 100 "check lshowmount lists MGS, MDT, OST and 0@lo"
8244
8245 test_101a() {
8246         local createmany_pid
8247         local dev=$FSNAME-OST0000-osc-MDT0000
8248         setup
8249
8250         mkdir $DIR1/$tdir
8251         do_nodes $(comma_list $(osts_nodes)) $LCTL set_param \
8252                 seq.*OST*-super.width=$DATA_SEQ_MAX_WIDTH
8253         createmany -o $DIR1/$tdir/$tfile-%d 50000 &
8254         createmany_pid=$!
8255         # MDT->OST reconnection causes MDT<->OST last_id synchornisation
8256         # via osp_precreate_cleanup_orphans.
8257         for ((i = 0; i < 100; i++)); do
8258                 for ((k = 0; k < 10; k++)); do
8259                         do_facet $SINGLEMDS "$LCTL --device $dev deactivate;" \
8260                                             "$LCTL --device $dev activate"
8261                 done
8262
8263                 ls -asl $MOUNT | grep '???' &&
8264                         { kill -9 $createmany_pid &>/dev/null;
8265                           error "File has no object on OST"; }
8266
8267                 kill -s 0 $createmany_pid || break
8268         done
8269         wait $createmany_pid
8270
8271         unlinkmany $DIR1/$tdir/$tfile-%d 50000
8272         cleanup
8273 }
8274 run_test 101a "Race MDT->OST reconnection with create"
8275
8276 test_101b () {
8277         local dev=$FSNAME-OST0000-osc-MDT0000
8278         local dir=$DIR1/$tdir
8279         setup
8280
8281         mkdir $dir
8282         $LFS setstripe -c 1 -i 0 $dir
8283         do_facet $SINGLEMDS "$LCTL --device $dev deactivate;"
8284 #define OBD_FAIL_OSP_CON_EVENT_DELAY 0x2107
8285         do_facet mds1 "$LCTL set_param fail_loc=0x80002107 fail_val=20"
8286         do_facet $SINGLEMDS "$LCTL --device $dev activate;"
8287         stop_ost
8288         sleep 25
8289         start_ost
8290
8291         wait_osc_import_ready client ost1
8292         touch $dir/$tfile || error "Can't create file"
8293
8294         cleanup
8295 }
8296 run_test 101b "Race events DISCONNECT and ACTIVE in osp"
8297
8298 test_102() {
8299         [[ "$MDS1_VERSION" -gt $(version_code 2.9.53) ]] ||
8300                 skip "Need server version greater than 2.9.53"
8301         [[ “$(mdsdevname 1)” != “$(mgsdevname)” ]] &&
8302                 [[ “$(facet_host mds1)” = “$(facet_host mgs)” ]] &&
8303                 skip "MGS must be on different node or combined"
8304
8305         cleanup || error "cleanup failed with $?"
8306
8307         local mds1dev=$(mdsdevname 1)
8308         local mds1mnt=$(facet_mntpt mds1)
8309         local mds1opts=$MDS_MOUNT_OPTS
8310
8311         if [ "$mds1_FSTYPE" == ldiskfs ] &&
8312            ! do_facet mds1 test -b $mds1dev; then
8313                 mds1opts=$(csa_add "$mds1opts" -o loop)
8314         fi
8315         if [[ "$mds1_FSTYPE" == zfs ]]; then
8316                 import_zpool mds1 || return ${PIPESTATUS[0]}
8317         fi
8318
8319         # unload all and only load libcfs to allow fail_loc setting
8320         do_facet mds1 $LUSTRE_RMMOD || error "unable to unload modules"
8321         do_facet mds1 modprobe libcfs || error "libcfs not loaded"
8322         do_facet mds1 lsmod \| grep libcfs || error "libcfs not loaded"
8323
8324         #define OBD_FAIL_OBDCLASS_MODULE_LOAD    0x60a
8325         do_facet mds1 "$LCTL set_param fail_loc=0x8000060a"
8326
8327         do_facet mds1 $MOUNT_CMD $mds1dev $mds1mnt $mds1opts &&
8328                 error "mdt start must fail"
8329         do_facet mds1 lsmod \| grep  obdclass && error "obdclass must not load"
8330
8331         do_facet mds1 "$LCTL set_param fail_loc=0x0"
8332
8333         do_facet mds1 $MOUNT_CMD $mds1dev $mds1mnt $mds1opts ||
8334                 error "mdt start must not fail"
8335
8336         cleanup || error "cleanup failed with $?"
8337 }
8338 run_test 102 "obdclass module cleanup upon error"
8339
8340 test_renamefs() {
8341         local newname=$1
8342
8343         echo "rename $FSNAME to $newname"
8344
8345         if ! combined_mgs_mds ; then
8346                 local dev=$(mgsdevname)
8347
8348                 do_facet mgs \
8349                         "$TUNEFS --fsname=$newname --rename=$FSNAME -v $dev" ||
8350                                 error "(7) Fail to rename MGS"
8351                 if [ "$(facet_fstype mgs)" = "zfs" ]; then
8352                         reimport_zpool mgs $newname-mgs
8353                 fi
8354         fi
8355
8356         for num in $(seq $MDSCOUNT); do
8357                 local dev=$(mdsdevname $num)
8358
8359                 do_facet mds${num} \
8360                         "$TUNEFS --fsname=$newname --rename=$FSNAME -v $dev" ||
8361                                 error "(8) Fail to rename MDT $num"
8362                 if [ "$(facet_fstype mds${num})" = "zfs" ]; then
8363                         reimport_zpool mds${num} $newname-mdt${num}
8364                 fi
8365         done
8366
8367         for num in $(seq $OSTCOUNT); do
8368                 local dev=$(ostdevname $num)
8369
8370                 do_facet ost${num} \
8371                         "$TUNEFS --fsname=$newname --rename=$FSNAME -v $dev" ||
8372                                 error "(9) Fail to rename OST $num"
8373                 if [ "$(facet_fstype ost${num})" = "zfs" ]; then
8374                         reimport_zpool ost${num} $newname-ost${num}
8375                 fi
8376         done
8377 }
8378
8379 test_103_set_pool() {
8380         local pname=$1
8381         local ost_x=$2
8382
8383         do_facet mgs $LCTL pool_add $FSNAME.$pname ${FSNAME}-$ost_x ||
8384                 error "Fail to add $ost_x to $FSNAME.$pname"
8385         wait_update $HOSTNAME \
8386                 "lctl get_param -n lov.$FSNAME-clilov-*.pools.$pname |
8387                  grep $ost_x" "$FSNAME-${ost_x}_UUID" ||
8388                 error "$ost_x is NOT in pool $FSNAME.$pname"
8389 }
8390
8391 test_103_check_pool() {
8392         local save_fsname=$1
8393         local errno=$2
8394
8395         stat $DIR/$tdir/test-framework.sh ||
8396                 error "($errno) Fail to stat"
8397         do_facet mgs $LCTL pool_list $FSNAME.pool1 ||
8398                 error "($errno) Fail to list $FSNAME.pool1"
8399         do_facet mgs $LCTL pool_list $FSNAME.$save_fsname ||
8400                 error "($errno) Fail to list $FSNAME.$save_fsname"
8401         do_facet mgs $LCTL pool_list $FSNAME.$save_fsname |
8402                 grep ${FSNAME}-OST0000 ||
8403                 error "($errno) List $FSNAME.$save_fsname is invalid"
8404
8405         local pname=$($LFS getstripe --pool $DIR/$tdir/d0)
8406         [ "$pname" = "$save_fsname" ] ||
8407                 error "($errno) Unexpected pool name $pname"
8408 }
8409
8410 test_103() {
8411         check_mount_and_prep
8412         rm -rf $DIR/$tdir
8413         mkdir $DIR/$tdir || error "(1) Fail to mkdir $DIR/$tdir"
8414         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir ||
8415                 error "(2) Fail to copy test-framework.sh"
8416
8417         do_facet mgs $LCTL pool_new $FSNAME.pool1 ||
8418                 error "(3) Fail to create $FSNAME.pool1"
8419         # name the pool name as the fsname
8420         do_facet mgs $LCTL pool_new $FSNAME.$FSNAME ||
8421                 error "(4) Fail to create $FSNAME.$FSNAME"
8422
8423         test_103_set_pool $FSNAME OST0000
8424
8425         $LFS setstripe -p $FSNAME $DIR/$tdir/d0 ||
8426                 error "(6) Fail to setstripe on $DIR/$tdir/d0"
8427
8428         KEEP_ZPOOL=true
8429         stopall
8430
8431         test_renamefs mylustre
8432
8433         local save_fsname=$FSNAME
8434         FSNAME="mylustre"
8435         setupall
8436
8437         test_103_check_pool $save_fsname 7
8438
8439         if [ $OSTCOUNT -ge 2 ]; then
8440                 test_103_set_pool $save_fsname OST0001
8441         fi
8442
8443         $LFS setstripe -p $save_fsname $DIR/$tdir/f0 ||
8444                 error "(16) Fail to setstripe on $DIR/$tdir/f0"
8445
8446         stopall
8447
8448         test_renamefs tfs
8449
8450         FSNAME="tfs"
8451         setupall
8452
8453         test_103_check_pool $save_fsname 17
8454
8455         stopall
8456
8457         test_renamefs $save_fsname
8458
8459         FSNAME=$save_fsname
8460         setupall
8461         KEEP_ZPOOL=false
8462 }
8463 run_test 103 "rename filesystem name"
8464
8465 test_104a() { # LU-6952
8466         local mds_mountopts=$MDS_MOUNT_OPTS
8467         local ost_mountopts=$OST_MOUNT_OPTS
8468         local mds_mountfsopts=$MDS_MOUNT_FS_OPTS
8469         local lctl_ver=$(do_facet $SINGLEMDS $LCTL --version |
8470                         awk '{ print $2 }')
8471
8472         [[ $(version_code $lctl_ver) -lt $(version_code 2.9.55) ]] &&
8473                 skip "this test needs utils above 2.9.55"
8474
8475         # specify "acl" in mount options used by mkfs.lustre
8476         if [ -z "$MDS_MOUNT_FS_OPTS" ]; then
8477                 MDS_MOUNT_FS_OPTS="acl,user_xattr"
8478         else
8479
8480                 MDS_MOUNT_FS_OPTS="${MDS_MOUNT_FS_OPTS},acl,user_xattr"
8481         fi
8482
8483         echo "mountfsopt: $MDS_MOUNT_FS_OPTS"
8484
8485         #reformat/remount the MDT to apply the MDT_MOUNT_FS_OPT options
8486         formatall
8487         if ! combined_mgs_mds ; then
8488                 start_mgs
8489         fi
8490
8491         if [ -z "$MDS_MOUNT_OPTS" ]; then
8492                 MDS_MOUNT_OPTS="-o noacl"
8493         else
8494                 MDS_MOUNT_OPTS="${MDS_MOUNT_OPTS},noacl"
8495         fi
8496
8497         for num in $(seq $MDSCOUNT); do
8498                 start mds$num $(mdsdevname $num) $MDS_MOUNT_OPTS ||
8499                         error "Failed to start MDS"
8500         done
8501
8502         for num in $(seq $OSTCOUNT); do
8503                 start ost$num $(ostdevname $num) $OST_MOUNT_OPTS ||
8504                         error "Failed to start OST"
8505         done
8506
8507         mount_client $MOUNT
8508         setfacl -m "d:$RUNAS_ID:rwx" $MOUNT &&
8509                 error "ACL is applied when FS is mounted with noacl."
8510
8511         MDS_MOUNT_OPTS=$mds_mountopts
8512         OST_MOUNT_OPTS=$ost_mountopts
8513         MDS_MOUNT_FS_OPTS=$mds_mountfsopts
8514 }
8515 run_test 104a "Make sure user defined options are reflected in mount"
8516
8517 test_104b() { # LU-12859
8518         mount_client $MOUNT3 flock,localflock
8519         stack_trap "umount_client $MOUNT3" EXIT
8520         mount | grep "$MOUNT3 .*,flock" && error "flock is still set"
8521         mount | grep "$MOUNT3 .*,localflock" || error "localflock is not set"
8522         umount_client $MOUNT3
8523         mount_client $MOUNT3 localflock,flock
8524         mount | grep "$MOUNT3 .*,localflock" && error "localflock is still set"
8525         mount | grep "$MOUNT3 .*,flock" || error "flock is not set"
8526         umount_client $MOUNT3
8527         mount_client $MOUNT3 localflock,flock,noflock
8528         flock_is_enabled $MOUNT3 && error "some flock is still enabled" || true
8529 }
8530 run_test 104b "Mount uses last flock argument"
8531
8532 error_and_umount() {
8533         umount $TMP/$tdir
8534         rmdir $TMP/$tdir
8535         error $*
8536 }
8537
8538 test_105() {
8539         cleanup -f
8540         reformat
8541         setup_noconfig
8542         mkdir -p $TMP/$tdir
8543         mount --bind $DIR $TMP/$tdir || error "mount bind mnt pt failed"
8544         rm -f $TMP/$tdir/$tfile
8545         rm -f $TMP/$tdir/${tfile}1
8546
8547         # Files should not be created in ro bind mount point
8548         # remounting from rw to ro
8549         mount -o remount,ro $TMP/$tdir ||
8550                 error_and_umount "readonly remount of bind mnt pt failed"
8551         touch $TMP/$tdir/$tfile &&
8552                 error_and_umount "touch succeeds on ro bind mnt pt"
8553         [ -e $TMP/$tdir/$tfile ] &&
8554                 error_and_umount "file created on ro bind mnt pt"
8555
8556         # Files should be created in rw bind mount point
8557         # remounting from ro to rw
8558         mount -o remount,rw $TMP/$tdir ||
8559                 error_and_umount "read-write remount of bind mnt pt failed"
8560         touch $TMP/$tdir/${tfile}1 ||
8561                 error_and_umount "touch fails on rw bind mnt pt"
8562         [ -e $TMP/$tdir/${tfile}1 ] ||
8563                 error_and_umount "file not created on rw bind mnt pt"
8564         umount $TMP/$tdir || error "umount of bind mnt pt failed"
8565         rmdir $TMP/$tdir
8566         cleanup || error "cleanup failed with $?"
8567 }
8568 run_test 105 "check file creation for ro and rw bind mnt pt"
8569
8570 test_106() {
8571         local repeat=5
8572         local creates=64768     # one full plain llog
8573
8574         # ensure there are enough inodes in the filesystem
8575         (( OSTSIZE < (creates + 1024) * 8)) && OSTSIZE=$(((creates + 1024) * 8))
8576         reformat
8577         setup_noconfig
8578         lfs df -i
8579         mkdir -p $DIR/$tdir || error "create $tdir failed"
8580         do_nodes $(comma_list $(osts_nodes)) $LCTL set_param \
8581                 seq.*OST*-super.width=$DATA_SEQ_MAX_WIDTH
8582         lfs setstripe -c 1 -i 0 $DIR/$tdir
8583 #define OBD_FAIL_CAT_RECORDS                        0x1312
8584         do_facet mds1 $LCTL set_param fail_loc=0x1312 fail_val=$repeat
8585
8586         for ((i = 1; i <= $repeat; i++)); do
8587                 createmany -o $DIR/$tdir/f- $creates || lfs df -i
8588                 createmany -u $DIR/$tdir/f- $creates
8589                 wait_delete_completed $((TIMEOUT * 7))
8590         done
8591 #ASSERTION osp_sync_thread() ( thread->t_flags != SVC_RUNNING ) failed
8592 #shows that osp code is buggy
8593         do_facet mds1 $LCTL set_param fail_loc=0 fail_val=0
8594
8595         cleanup
8596 }
8597 run_test 106 "check osp llog processing when catalog is wrapped"
8598
8599 test_107() {
8600         [[ "$MDS1_VERSION" -ge $(version_code 2.10.50) ]] ||
8601                 skip "Need MDS version > 2.10.50"
8602         local cmd
8603
8604         start_mgsmds || error "start_mgsmds failed"
8605         start_ost || error "unable to start OST"
8606
8607         # add unknown configuration parameter.
8608         if [[ $PERM_CMD == *"set_param -P"* ]]; then
8609                 cmd="$PERM_CMD ost.$FSNAME-OST0000*.unknown_param"
8610         else
8611                 cmd="$PERM_CMD $FSNAME-OST0000*.ost.unknown_param"
8612         fi
8613         do_facet mgs "$cmd=50"
8614         cleanup_nocli || error "cleanup_nocli failed with $?"
8615         load_modules
8616
8617         # unknown param should be ignored while mounting.
8618         start_ost || error "unable to start OST after unknown param set"
8619
8620         cleanup || error "cleanup failed with $?"
8621 }
8622 run_test 107 "Unknown config param should not fail target mounting"
8623
8624 t_108_prep() {
8625         local facet
8626
8627         $rcmd rm -rf $tmp > /dev/null 2>&1
8628         $rcmd mkdir -p $tmp/{mnt,images} || error "failed to mkdir remotely"
8629
8630         for facet in $facets; do
8631                 [ "$mds1_FSTYPE" = zfs ] &&
8632                         $rcmd $ZPOOL -f export lustre-$facet > /dev/null 2>&1
8633                 $rcmd mkdir $tmp/mnt/$facet ||
8634                         error "failed to mkdir $tmp/mnt/$facet"
8635                 $rcmd dd if=/dev/zero of=$tmp/images/$facet \
8636                         seek=199 bs=1M count=1 ||
8637                         error "failed to create $tmp/images/$facet"
8638         done
8639 }
8640
8641 t_108_mkfs() {
8642         local role=$1
8643         local idx=$2
8644         local bkfs=$3
8645         local mgs=$4
8646         local facet=${role}$((idx + 1))
8647         local pool=""
8648         [ $# -eq 5 ] && pool=$5
8649
8650         do_facet $SINGLEMDS $MKFS --fsname=lustre --$mgs \
8651                 --$role --index=$idx --replace --backfstype=$bkfs \
8652                 --device-size=200000 --reformat $pool $tmp/images/$facet ||
8653                 error "failed to mkfs for $facet"
8654 }
8655
8656 t_108_check() {
8657         echo "mounting client..."
8658         mount -t lustre ${nid}:/lustre $MOUNT ||
8659                 error "failed to mount lustre"
8660
8661         echo "check list"
8662         ls -l $MOUNT/local_dir || error "failed to list"
8663
8664         echo "check truncate && write"
8665         echo "dummmmmmmmmmmmm" > $MOUNT/remote_dir/fsx.c ||
8666                 error "failed to tuncate & write"
8667
8668         echo "check create"
8669         touch $MOUNT/foooo ||
8670                 error "failed to create"
8671
8672         echo "check read && write && append"
8673         sha1sum $MOUNT/conf-sanity.sh |
8674                 awk '{ print $1 }' > $MOUNT/checksum.new ||
8675                 error "failed to read(1)"
8676         sha1sum $MOUNT/remote_dir/unlinkmany.c |
8677                 awk '{ print $1 }' >> $MOUNT/checksum.new ||
8678                 error "failed to read(2)"
8679         sha1sum $MOUNT/striped_dir/lockahead_test.o |
8680                 awk '{ print $1 }' >> $MOUNT/checksum.new ||
8681                 error "failed to read(3)"
8682
8683         echo "verify data"
8684         diff $MOUNT/checksum.new $MOUNT/checksum.src ||
8685                 error "failed to verify data"
8686
8687         echo "done."
8688 }
8689
8690 t_108_cleanup() {
8691         trap 0
8692         local facet
8693
8694         echo "cleanup..."
8695         umount -f $MOUNT || error "failed to umount client"
8696         for facet in $facets; do
8697                 $rcmd umount -f $tmp/mnt/$facet ||
8698                         error "failed to umount $facet"
8699                 if [ "$mds1_FSTYPE" = zfs ]; then
8700                         $rcmd $ZPOOL export -f lustre-$facet ||
8701                                 error "failed to export lustre-$facet"
8702                 fi
8703         done
8704
8705         $rcmd rm -rf $tmp || error "failed to rm the dir $tmp"
8706 }
8707
8708 test_108a() {
8709         [ "$CLIENTONLY" ] && skip "Client-only testing"
8710         [ "$mds1_FSTYPE" != zfs ] && skip "zfs only test"
8711         [ "$MDS1_VERSION" -lt $(version_code 2.10.58) ] &&
8712                 skip "Need server version at least 2.10.58"
8713
8714         stopall
8715         load_modules
8716
8717         local tmp=$TMP/$tdir
8718         local rcmd="do_facet $SINGLEMDS"
8719         local facets="mdt1 mdt2 ost1 ost2"
8720         local nid=$($rcmd $LCTL list_nids | head -1)
8721         local facet
8722
8723         trap t_108_cleanup EXIT ERR
8724         t_108_prep
8725
8726         t_108_mkfs mdt 0 zfs mgs lustre-mdt1/mdt1
8727         t_108_mkfs mdt 1 zfs mgsnode=$nid lustre-mdt2/mdt2
8728         t_108_mkfs ost 0 zfs mgsnode=$nid lustre-ost1/ost1
8729         t_108_mkfs ost 1 zfs mgsnode=$nid lustre-ost2/ost2
8730
8731         for facet in $facets; do
8732                 $rcmd zfs set mountpoint=$tmp/mnt/$facet canmount=on \
8733                         lustre-$facet/$facet ||
8734                         error "failed to zfs set for $facet (1)"
8735                 $rcmd zfs mount lustre-$facet/$facet ||
8736                         error "failed to local mount $facet"
8737                 $rcmd tar jxf $LUSTRE/tests/ldiskfs_${facet}_2_11.tar.bz2 \
8738                         --xattrs --xattrs-include="trusted.*" \
8739                         -C $tmp/mnt/$facet/ > /dev/null 2>&1 ||
8740                         error "failed to untar image for $facet"
8741                 $rcmd "cd $tmp/mnt/$facet && rm -rf oi.* OI_* lfsck_* LFSCK" ||
8742                         error "failed to cleanup for $facet"
8743                 $rcmd zfs umount lustre-$facet/$facet ||
8744                         error "failed to local umount $facet"
8745                 $rcmd zfs set canmount=off lustre-$facet/$facet ||
8746                         error "failed to zfs set $facet (2)"
8747         done
8748
8749         echo "changing server nid..."
8750         $rcmd mount -t lustre -o nosvc lustre-mdt1/mdt1 $tmp/mnt/mdt1
8751         $rcmd lctl replace_nids $FSNAME-MDT0000 $nid
8752         $rcmd lctl replace_nids $FSNAME-MDT0001 $nid
8753         $rcmd lctl replace_nids $FSNAME-OST0000 $nid
8754         $rcmd lctl replace_nids $FSNAME-OST0001 $nid
8755         $rcmd umount $tmp/mnt/mdt1
8756
8757         for facet in $facets; do
8758                 echo "mounting $facet from backup..."
8759                 $rcmd mount -t lustre -o abort_recov lustre-$facet/$facet \
8760                         $tmp/mnt/$facet || error "failed to mount $facet"
8761         done
8762
8763         # ZFS backend can detect migration and trigger OI scrub automatically
8764         # sleep 3 seconds for scrub done
8765         sleep 3
8766
8767         t_108_check
8768         t_108_cleanup
8769 }
8770 run_test 108a "migrate from ldiskfs to ZFS"
8771
8772 test_108b() {
8773         [ "$CLIENTONLY" ] && skip "Client-only testing"
8774         [ "$mds1_FSTYPE" != ldiskfs ] && skip "ldiskfs only test"
8775         [ "$MDS1_VERSION" -lt $(version_code 2.10.58) ] &&
8776                 skip "Need server version at least 2.10.58"
8777
8778         stopall
8779         load_modules
8780
8781         local tmp=$TMP/$tdir
8782         local rcmd="do_facet $SINGLEMDS"
8783         local facets="mdt1 mdt2 ost1 ost2"
8784         local scrub_list="MDT0000 MDT0001 OST0000 OST0001"
8785         local nid=$($rcmd $LCTL list_nids | head -1)
8786         local facet
8787
8788         trap t_108_cleanup EXIT ERR
8789         t_108_prep
8790
8791         t_108_mkfs mdt 0 ldiskfs mgs
8792         t_108_mkfs mdt 1 ldiskfs mgsnode=$nid
8793         t_108_mkfs ost 0 ldiskfs mgsnode=$nid
8794         t_108_mkfs ost 1 ldiskfs mgsnode=$nid
8795
8796         for facet in $facets; do
8797                 $rcmd mount -t ldiskfs -o loop $tmp/images/$facet \
8798                         $tmp/mnt/$facet ||
8799                         error "failed to local mount $facet"
8800
8801                 $rcmd tar jxf $LUSTRE/tests/zfs_${facet}_2_11.tar.bz2 \
8802                         --xattrs --xattrs-include="*.*" \
8803                         -C $tmp/mnt/$facet/ > /dev/null 2>&1 ||
8804                         error "failed to untar image for $facet"
8805                 $rcmd "cd $tmp/mnt/$facet && rm -rf oi.* OI_* lfsck_* LFSCK" ||
8806                         error "failed to cleanup for $facet"
8807                 $rcmd umount $tmp/mnt/$facet ||
8808                         error "failed to local umount $facet"
8809         done
8810
8811         echo "changing server nid..."
8812         $rcmd mount -t lustre -o nosvc,loop $tmp/images/mdt1 $tmp/mnt/mdt1
8813         $rcmd lctl replace_nids $FSNAME-MDT0000 $nid
8814         $rcmd lctl replace_nids $FSNAME-MDT0001 $nid
8815         $rcmd lctl replace_nids $FSNAME-OST0000 $nid
8816         $rcmd lctl replace_nids $FSNAME-OST0001 $nid
8817         $rcmd umount $tmp/mnt/mdt1
8818
8819         for facet in $facets; do
8820                 echo "mounting $facet from backup..."
8821                 $rcmd mount -t lustre -o loop,abort_recov $tmp/images/$facet \
8822                         $tmp/mnt/$facet || error "failed to mount $facet"
8823         done
8824
8825         for facet in $scrub_list; do
8826                 $rcmd $LCTL lfsck_start -M $FSNAME-$facet -t scrub ||
8827                         error "failed to start OI scrub on $facet"
8828         done
8829
8830         # sleep 3 seconds for scrub done
8831         sleep 3
8832
8833         t_108_check
8834         t_108_cleanup
8835 }
8836 run_test 108b "migrate from ZFS to ldiskfs"
8837
8838 #
8839 # set number of permanent parameters
8840 #
8841 test_109_set_params() {
8842         local fsname=$1
8843
8844         set_persistent_param_and_check mds                          \
8845             "mdd.$fsname-MDT0000.atime_diff"                        \
8846             "$fsname-MDT0000.mdd.atime_diff"                        \
8847             "62"
8848         set_persistent_param_and_check mds                          \
8849             "mdd.$fsname-MDT0000.atime_diff"                        \
8850             "$fsname-MDT0000.mdd.atime_diff"                        \
8851             "63"
8852         set_persistent_param_and_check client                       \
8853             "llite.$fsname*.max_read_ahead_mb"                      \
8854             "$fsname.llite.max_read_ahead_mb"                       \
8855             "32"
8856         set_persistent_param_and_check client                       \
8857             "llite.$fsname*.max_read_ahead_mb"                      \
8858             "$fsname.llite.max_read_ahead_mb"                       \
8859             "64"
8860         create_pool $fsname.pool1 || error "create pool failed"
8861         do_facet mgs $LCTL pool_add $fsname.pool1 OST0000 ||
8862                 error "pool_add failed"
8863         do_facet mgs $LCTL pool_remove $fsname.pool1 OST0000 ||
8864                 error "pool_remove failed"
8865         do_facet mgs $LCTL pool_add $fsname.pool1 OST0000 ||
8866                 error "pool_add failed"
8867 }
8868
8869 #
8870 # check permanent parameters
8871 #
8872 test_109_test_params() {
8873         local fsname=$1
8874
8875         local atime_diff=$(do_facet mds $LCTL \
8876                 get_param -n mdd.$fsname-MDT0000.atime_diff)
8877         [ $atime_diff == 63 ] || error "wrong mdd parameter after clear_conf"
8878         local max_read_ahead_mb=$(do_facet client $LCTL \
8879                 get_param -n llite.$fsname*.max_read_ahead_mb)
8880         [ $max_read_ahead_mb == 64 ] ||
8881                 error "wrong llite parameter after clear_conf"
8882         local ost_in_pool=$(do_facet mds $LCTL pool_list $fsname.pool1 |
8883                 grep -v "^Pool:" | sed 's/_UUID//')
8884         [ $ost_in_pool = "$fsname-OST0000" ] ||
8885                 error "wrong pool after clear_conf"
8886 }
8887
8888 #
8889 # run lctl clear_conf, store CONFIGS before and after that
8890 #
8891 test_109_clear_conf()
8892 {
8893         local clear_conf_arg=$1
8894
8895         local mgsdev
8896         if ! combined_mgs_mds ; then
8897                 mgsdev=$(mgsdevname)
8898                 stop_mgs || error "stop_mgs failed"
8899                 start_mgs "-o nosvc" || error "start_mgs nosvc failed"
8900         else
8901                 mgsdev=$(mdsdevname 1)
8902                 start_mdt 1 "-o nosvc" || error "start_mdt 1 nosvc failed"
8903         fi
8904
8905         do_facet mgs "rm -rf $TMP/${tdir}/conf1; mkdir -p $TMP/${tdir}/conf1;" \
8906                 "$DEBUGFS -c -R \\\"rdump CONFIGS $TMP/${tdir}/conf1\\\" \
8907                 $mgsdev"
8908
8909         #
8910         # the command being tested
8911         #
8912         do_facet mgs $LCTL clear_conf $clear_conf_arg ||
8913                 error "clear_conf failed"
8914         if ! combined_mgs_mds ; then
8915                 stop_mgs || error "stop_mgs failed"
8916         else
8917                 stop_mdt 1 || error "stop_mdt 1 failed"
8918         fi
8919
8920         do_facet mgs "rm -rf $TMP/${tdir}/conf2; mkdir -p $TMP/${tdir}/conf2;" \
8921                 "$DEBUGFS -c -R \\\"rdump CONFIGS $TMP/${tdir}/conf2\\\" \
8922                 $mgsdev"
8923 }
8924
8925 test_109_file_shortened() {
8926         local file=$1
8927         local sizes=($(do_facet mgs "stat -c %s " \
8928                 "$TMP/${tdir}/conf1/CONFIGS/$file" \
8929                 "$TMP/${tdir}/conf2/CONFIGS/$file"))
8930         [ ${sizes[1]} -lt ${sizes[0]} ] && return 0
8931         return 1
8932 }
8933
8934 test_109a()
8935 {
8936         [ $MDS1_VERSION -lt $(version_code 2.10.59) ] &&
8937                 skip "Needs MDS version 2.10.59 or later."
8938         [ "$(facet_fstype mgs)" == zfs ] &&
8939                 skip "LU-8727: no implementation for ZFS"
8940
8941         stopall
8942         reformat
8943         setup_noconfig
8944         client_up || error "client_up failed"
8945
8946         #
8947         # set number of permanent parameters
8948         #
8949         test_109_set_params $FSNAME
8950
8951         umount_client $MOUNT || error "umount_client failed"
8952         stop_ost || error "stop_ost failed"
8953         stop_mds || error "stop_mds failed"
8954
8955         test_109_clear_conf $FSNAME
8956         #
8957         # make sure that all configs are cleared
8958         #
8959         test_109_file_shortened $FSNAME-MDT0000 ||
8960                 error "failed to clear MDT0000 config"
8961         test_109_file_shortened $FSNAME-client ||
8962                 error "failed to clear client config"
8963
8964         setup_noconfig
8965
8966         #
8967         # check that configurations are intact
8968         #
8969         test_109_test_params $FSNAME
8970
8971         #
8972         # Destroy pool.
8973         #
8974         destroy_test_pools || error "destroy test pools failed"
8975
8976         cleanup
8977 }
8978 run_test 109a "test lctl clear_conf fsname"
8979
8980 test_109b()
8981 {
8982         [ $MDS1_VERSION -lt $(version_code 2.10.59) ] &&
8983                 skip "Needs MDS version 2.10.59 or later."
8984         [ "$(facet_fstype mgs)" == zfs ] &&
8985                 skip "LU-8727: no implementation for ZFS"
8986
8987         stopall
8988         reformat
8989         setup_noconfig
8990         client_up || error "client_up failed"
8991
8992         #
8993         # set number of permanent parameters
8994         #
8995         test_109_set_params $FSNAME
8996
8997         umount_client $MOUNT || error "umount_client failed"
8998         stop_ost || error "stop_ost failed"
8999         stop_mds || error "stop_mds failed"
9000
9001         test_109_clear_conf $FSNAME-MDT0000
9002         #
9003         # make sure that only one config is cleared
9004         #
9005         test_109_file_shortened $FSNAME-MDT0000 ||
9006                 error "failed to clear MDT0000 config"
9007         test_109_file_shortened $FSNAME-client &&
9008                 error "failed to clear client config"
9009
9010         setup_noconfig
9011         #
9012         # check that configurations are intact
9013         #
9014         test_109_test_params $FSNAME
9015
9016         #
9017         # Destroy pool.
9018         #
9019         destroy_test_pools || error "destroy test pools failed"
9020
9021         cleanup
9022 }
9023 run_test 109b "test lctl clear_conf one config"
9024
9025 test_110()
9026 {
9027         [[ "$mds1_FSTYPE" != ldiskfs ]] &&
9028                 skip "Only applicable to ldiskfs-based MDTs"
9029
9030         do_facet $SINGLEMDS $DEBUGFS -w -R supported_features |grep large_dir ||
9031                 skip "large_dir option is not supported on MDS"
9032         do_facet ost1 $DEBUGFS -w -R supported_features | grep large_dir ||
9033                 skip "large_dir option is not supported on OSS"
9034
9035         stopall # stop all targets before modifying the target counts
9036         local old_mdscount=$MDSCOUNT
9037         local old_ostcount=$OSTCOUNT
9038         local replace=""
9039         stack_trap "MDSCOUNT=$old_mdscount OSTCOUNT=$old_ostcount; reformat"
9040         MDSCOUNT=1
9041         OSTCOUNT=1
9042
9043         # ext4_dir_entry_2 struct size:264
9044         # dx_root struct size:8
9045         # dx_node struct size:8
9046         # dx_entry struct size:8
9047         # For 1024 bytes block size.
9048         # First level directory entries: 126
9049         # Second level directory entries: 127
9050         # Entries in leaf: 3
9051         # For 2 levels limit: 48006
9052         # For 3 levels limit : 6096762
9053         # Create 80000 files to safely exceed 2-level htree limit.
9054         CONF_SANITY_110_LINKS=${CONF_SANITY_110_LINKS:-80000}
9055
9056         # can fit at most 3 filenames per 1KB leaf block, but each
9057         # leaf/index block will only be 3/4 full before split at each level
9058         (( MDSSIZE < CONF_SANITY_110_LINKS / 3 * 4/3 * 4/3 )) &&
9059                 CONF_SANITY_110_LINKS=$((MDSSIZE * 3 * 3/4 * 3/4))
9060
9061         combined_mgs_mds || replace=" --replace "
9062         local opts="$(mkfs_opts mds1 $(mdsdevname 1)) \
9063                     $replace --reformat $(mdsdevname 1) $(mdsvdevname 1)"
9064         if [[ $opts != *large_dir* ]]; then
9065                 if [[ $opts != *mkfsoptions* ]]; then
9066                         opts+=" --mkfsoptions=\\\"-O large_dir -b 1024 -i 65536\\\""
9067                 else
9068                         opts="${opts//--mkfsoptions=\\\"/ \
9069                                 --mkfsoptions=\\\"-O large_dir -b 1024 -i 65536 }"
9070                 fi
9071         fi
9072         echo "MDT params: $opts"
9073         load_modules
9074         combined_mgs_mds || start_mgs
9075         add mds1 $opts || error "add mds1 failed with new params"
9076         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
9077
9078         opts="$(mkfs_opts ost1 $(ostdevname 1)) \
9079                 $replace --reformat $(ostdevname 1) $(ostvdevname 1)"
9080
9081         if [[ $opts != *large_dir* ]]; then
9082                 if [[ $opts != *mkfsoptions* ]]; then
9083                         opts+=" --mkfsoptions=\\\"-O large_dir\\\" "
9084                 else
9085                         opts="${opts//--mkfsoptions=\\\"/ \
9086                                 --mkfsoptions=\\\"-O large_dir }"
9087                 fi
9088         fi
9089         echo "OST params: $opts"
9090         add ost1 $opts || error "add ost1 failed with new params"
9091         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS
9092
9093         MOUNT_2=yes mountcli || error "mount clients failed"
9094
9095         mkdir -v $DIR/$tdir || error "cannot create $DIR/$tdir"
9096         local pids count=0 group=0
9097
9098         echo "creating $CONF_SANITY_110_LINKS in total"
9099         while (( count < CONF_SANITY_110_LINKS )); do
9100                 local len=$((253 - $(wc -c <<<"$tfile-$group-40000-")))
9101                 local dir=DIR$((group % 2 + 1))
9102                 local target=${!dir}/$tdir/$tfile-$group
9103                 local long=$target-$(generate_name $len)-
9104                 local create=$((CONF_SANITY_110_LINKS - count))
9105
9106                 (( create > 40000 )) && create=40000
9107                 touch $target || error "creating $target failed"
9108                 echo "creating $create hard links to $target"
9109                 createmany -l $target $long $create &
9110                 pids+=" $!"
9111
9112                 count=$((count + create))
9113                 group=$((group + 1))
9114         done
9115         echo "waiting for PIDs$pids to complete"
9116         wait $pids || error "createmany failed after $group groups"
9117
9118         umount_client $MOUNT2 -f
9119         cleanup
9120
9121         run_e2fsck $(facet_active_host mds1) $(mdsdevname 1) -n
9122         MDSCOUNT=$old_mdscount
9123         OSTCOUNT=$old_ostcount
9124 }
9125 run_test 110 "Adding large_dir with 3-level htree"
9126
9127 test_111() {
9128         [[ "$mds1_FSTYPE" != ldiskfs ]] &&
9129                 skip "Only applicable to ldiskfs-based MDTs"
9130
9131         is_dm_flakey_dev $SINGLEMDS $(mdsdevname 1) &&
9132                 skip "This test can not be executed on flakey dev"
9133
9134         do_facet $SINGLEMDS $DEBUGFS -w -R supported_features |grep large_dir ||
9135                 skip "large_dir option is not supported on MDS"
9136
9137         do_facet ost1 $DEBUGFS -w -R supported_features | grep large_dir ||
9138                 skip "large_dir option is not supported on OSS"
9139
9140         # cleanup before changing target counts
9141         cleanup
9142         local old_mdscount=$MDSCOUNT
9143         local old_ostcount=$OSTCOUNT
9144         local old_mdssize=$MDSSIZE
9145         local replace=""
9146         stack_trap "MDSSIZE=$old_mdssize MDSCOUNT=$old_mdscount \
9147                     OSTCOUNT=$old_ostcount; reformat"
9148         MDSCOUNT=1
9149         OSTCOUNT=1
9150         (( MDSSIZE < 2400000 )) && MDSSIZE=2400000 # need at least 2.4GB
9151
9152         local mdsdev=$(mdsdevname 1)
9153         combined_mgs_mds || replace=" --replace "
9154         local opts="$(mkfs_opts mds1 $(mdsdevname 1)) \
9155                     $replace --reformat $(mdsdevname 1) $(mdsvdevname 1)"
9156         if [[ $opts != *large_dir* ]]; then
9157                 if [[ $opts != *mkfsoptions* ]]; then
9158                         opts+=" --mkfsoptions=\\\"-O large_dir -i 1048576 \\\" "
9159                 else
9160                         opts="${opts//--mkfsoptions=\\\"/ \
9161                                 --mkfsoptions=\\\"-O large_dir -i 1048576 }"
9162                 fi
9163         fi
9164         echo "MDT params: $opts"
9165         load_modules
9166         combined_mgs_mds || start_mgs
9167         __touch_device mds 1
9168         add mds1 $opts || error "add mds1 failed with new params"
9169         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
9170
9171         opts="$(mkfs_opts ost1 $(ostdevname 1)) \
9172                 $replace --reformat $(ostdevname 1) $(ostvdevname 1)"
9173         if [[ $opts != *large_dir* ]]; then
9174                 if [[ $opts != *mkfsoptions* ]]; then
9175                         opts+=" --mkfsoptions=\\\"-O large_dir \\\""
9176                 else
9177                         opts="${opts//--mkfsoptions=\\\"/ --mkfsoptions=\\\"-O large_dir }"
9178                 fi
9179         fi
9180         echo "OST params: $opts"
9181         __touch_device ost 1
9182         add ost1 $opts || error "add ost1 failed with new params"
9183         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS
9184
9185         MOUNT_2=yes mountcli
9186         mkdir $DIR/$tdir || error "cannot create $DIR/$tdir"
9187         lfs df $DIR/$tdir
9188         lfs df -i $DIR/$tdir
9189
9190         local group=0
9191
9192         local start=$SECONDS
9193         local dirsize=0
9194         local dirmax=$((2 << 30))
9195         local needskip=0
9196         local taken=0
9197         local rate=0
9198         local left=0
9199         local num=0
9200         while (( !needskip & dirsize < dirmax )); do
9201                 local pids=""
9202
9203                 for cli in ${CLIENTS//,/ }; do
9204                         local len=$((253 - $(wc -c <<<"$cli-$group-60000-")))
9205                         local target=$cli-$group
9206                         local long=$DIR/$tdir/$target-$(generate_name $len)-
9207
9208                         RPWD=$DIR/$tdir do_node $cli touch $target ||
9209                                 error "creating $target failed"
9210                         echo "creating 60000 hardlinks to $target"
9211                         RPWD=$DIR/$tdir do_node $cli createmany -l $target $long 60000 &
9212                         pids+=" $!"
9213
9214                         group=$((group + 1))
9215                         target=$cli-$group
9216                         long=$DIR2/$tdir/$target-$(generate_name $len)-
9217
9218                         RPWD=$DIR2/$tdir do_node $cli touch $target ||
9219                                 error "creating $target failed"
9220                         echo "creating 60000 hardlinks to $target"
9221                         RPWD=$DIR2/$tdir do_node $cli createmany -l $target $long 60000 &
9222                         pids+=" $!"
9223
9224                         group=$((group + 1))
9225                 done
9226                 echo "waiting for PIDs$pids to complete"
9227                 wait $pids || error "createmany failed after $group groups"
9228                 dirsize=$(stat -c %s $DIR/$tdir)
9229                 taken=$((SECONDS - start))
9230                 rate=$((dirsize / taken))
9231                 left=$(((dirmax - dirsize) / rate))
9232                 num=$((group * 60000))
9233                 echo "estimate ${left}s left after $num files / ${taken}s"
9234                 # if the estimated time remaining is too large (it may change
9235                 # over time as the create rate is not constant) then exit
9236                 # without declaring a failure.
9237                 (( left > 1200 )) && needskip=1
9238         done
9239
9240         umount_client $MOUNT2 -f
9241         cleanup
9242
9243         ! (( $needskip )) ||
9244                 echo "ETA ${left}s after $num files / ${taken}s is too long"
9245
9246         run_e2fsck $(facet_active_host mds1) $(mdsdevname 1) -n
9247         MDSCOUNT=$old_mdscount
9248         OSTCOUNT=$old_ostcount
9249         MDSSIZE=$old_mdssize
9250 }
9251 run_test 111 "Adding large_dir with over 2GB directory"
9252
9253 test_112a() {
9254         local param="no_create"
9255
9256         (( $OST1_VERSION > $(version_code 2.14.0) )) ||
9257                 skip "need OSS at least 2.14.0"
9258         (( $OST1_VERSION >= $(version_code 2.15.56.125) )) ||
9259                 param="no_precreate"
9260
9261         start_mds || error "MDS start failed"
9262         start_ost || error "OSS start failed"
9263         echo "start ost2 service on $(facet_active_host ost2)"
9264         start ost2 $(ostdevname 2) $(csa_add "$OST_MOUNT_OPTS" -o $param) ||
9265                 error "start ost2 facet failed"
9266         local val=$(do_facet ost2 \
9267                    "$LCTL get_param -n obdfilter.$FSNAME-OST0001*.$param")
9268         (( $val == 1 )) || error "obdfilter.$FSNAME-OST0001*.$param=$val"
9269
9270         mount_client $MOUNT || error "mount client failed"
9271         wait_osc_import_state mds1 ost1 FULL
9272         wait_osc_import_ready client ost1
9273         wait_osc_import_ready client ost2
9274
9275         $LFS setstripe -i 0 $DIR/$tfile.0 ||
9276                 error "problem creating $tfile.0 on OST0000"
9277         $LFS setstripe -i 1 $DIR/$tfile.1 && $LFS getstripe $DIR/$tfile.1 &&
9278                 (( $($LFS getstripe -i $DIR/$tfile.1) == 1 )) &&
9279                 error "allowed to create $tfile.1 on OST0001"
9280         $LFS df -v $MOUNT
9281         $LFS df -v $MOUNT | grep -q "OST:1.*N" ||
9282                 error "NOCREATE not in 'lfs df'"
9283
9284         do_facet ost2 $LCTL set_param obdfilter.$FSNAME-OST0001*.$param=0
9285         sleep_maxage
9286         $LFS setstripe -i 1 $DIR/$tfile.2 ||
9287                 error "failed to create $tfile.2 on ost1 facet"
9288         # files not cleaned with ONLY_REPEAT because of client unmount below
9289         rm -f $DIR/$tfile.[012]
9290         stop_ost2 || error "stop ost2 facet failed"
9291         cleanup
9292 }
9293 run_test 112a "mount OST with no_create option"
9294
9295 test_112b() {
9296         (( MDSCOUNT >= 2 )) || skip "need at least 2 MDTs"
9297         (( $MDS1_VERSION >= $(version_code 2.15.56.125) )) ||
9298                 skip "need MDS >= 2.15.56.125"
9299         local mdsnum=$MDSCOUNT
9300         local facet=mds$mdsnum
9301         local mdtidx=$((mdsnum - 1))
9302         local mdtname=$FSNAME-MDT$(printf %04x $mdtidx)
9303
9304         start_mds --mdscount $((mdsnum - 1)) || error "MDS start failed"
9305         start_mdt $mdsnum -o no_create || error "start $facet failed"
9306         local val=$(do_facet $facet \
9307                    "$LCTL get_param -n mdt.$mdtname*.no_create")
9308         (( $val == 1 )) || error "mdt.$mdtname*.no_create=$val"
9309         start_ost || error "ost1 start failed"
9310         start_ost2 || error "ost1 start failed"
9311
9312         mount_client $MOUNT || error "mount client failed"
9313         wait_osc_import_ready $facet ost2
9314
9315         $LFS df -v $MOUNT
9316         $LFS df -v $MOUNT | grep -q "MDT:$mdtidx.*N" ||
9317                 error "NOCREATE not in 'lfs df'"
9318
9319         $LFS mkdir -i $mdtidx $DIR/$tdir ||
9320                 $LFS setdirstripe -D -c 1 -i -1 --max-inherit-rr 2 $DIR/$tdir ||
9321                 error "error creating $tdir on $mdtname"
9322         stack_trap "rm -rf $DIR/$tdir"
9323
9324         mkdir $DIR/$tdir/d1.{1..100} || error "mkdir $tdir/d1.{1..100} failed"
9325         $LFS getdirstripe -i $DIR/$tdir/d1.* | sort | uniq -c
9326         do_facet $facet $LCTL set_param mdt.$mdtname*.no_create=0
9327         # allow one initial create for delayed statfs on client
9328         (( $($LFS getdirstripe -i $DIR/$tdir/d1.* | grep -c $mdtidx) < 2 )) ||
9329                 error "allowed create on $mdtname"
9330         sleep_maxage_lmv
9331
9332         mkdir $DIR/$tdir/d2.{1..100} || error "mkdir $tdir/d2.{1..100} failed"
9333         $LFS getdirstripe -i $DIR/$tdir/d2.{1..100} | sort | uniq -c
9334         (( $($LFS getdirstripe -i $DIR/$tdir/d2.* | grep -c $mdtidx) > 10 )) ||
9335                 error "no create on $mdtname"
9336         # files not cleaned with ONLY_REPEAT because of client unmount below
9337         rm -r $DIR/$tdir
9338         stop_ost2 || error "ost1 start failed"
9339         cleanup
9340 }
9341 run_test 112b "mount MDT with no_create option"
9342
9343 # Global for 113
9344 SAVE_MGS_MOUNT_OPTS=$MGS_MOUNT_OPTS
9345 SAVE_MDS_MOUNT_OPTS=$MDS_MOUNT_OPTS
9346 SAVE_OST_MOUNT_OPTS=$OST_MOUNT_OPTS
9347
9348 cleanup_113() {
9349         trap 0
9350
9351         stopall
9352         MGS_MOUNT_OPTS=$SAVE_MGS_MOUNT_OPTS
9353         MDS_MOUNT_OPTS=$SAVE_MDS_MOUNT_OPTS
9354         OST_MOUNT_OPTS=$SAVE_OST_MOUNT_OPTS
9355         # Revert old mount options back
9356         setupall
9357         # Subsequent following test requires
9358         # conf-sanity to be in stopall state.
9359         # Force 'stopall' so others following
9360         # test can pass
9361         stopall
9362 }
9363
9364 # Error out with mount info
9365 error_113() {
9366         local server_nodes=$(comma_list $(mdts_nodes) $(osts_nodes))
9367         local err=$1
9368
9369         echo "--Client Mount Info--"
9370         mount | grep -i lustre
9371         echo "--Server Mount Info--"
9372         do_nodes $server_nodes mount | grep -i lustre
9373
9374         error $err
9375 }
9376
9377 test_113() {
9378         local ost_version="2.15.51" # Minimum version required
9379
9380         (( OST1_VERSION >= $(version_code $ost_version) )) ||
9381                 skip "Need server version at least $ost_version"
9382         sync; sleep 3
9383         stack_trap cleanup_113 EXIT
9384
9385         # Reset before starting
9386         stopall
9387         setupall
9388
9389         # Verify MDS's should start with "rw"
9390         do_facet $SINGLEMDS mount | grep "lustre.*rw,.*MDT" ||
9391                 error_113 "$SINGLEMDS should be read-write"
9392
9393         # Verify OST's should start with "rw"
9394         for (( i=1; i <= OSTCOUNT; i++ )); do
9395                 do_facet ost$i mount | grep "lustre.*rw,.*OST" ||
9396                         error_113 "ost$i should be read-write"
9397         done
9398
9399         # rdonly_dev does not currently work for ldiskfs
9400         # We skip the rdonly_dev check until then.
9401         if [[ $ost1_FSTYPE == ldiskfs ]]; then
9402                 echo "Shadow Mountpoint correctly reports rw for ldiskfs"
9403                 return 0
9404         fi
9405
9406         #
9407         # Only ZFS specific tests below.
9408         #
9409
9410         # Must stop all (server+client) and restart to verify new
9411         # mount options
9412         stopall
9413
9414         # add rdonly_dev to mount option
9415         MGS_MOUNT_OPTS=$(csa_add "$MGS_MOUNT_OPTS" -o rdonly_dev)
9416         MDS_MOUNT_OPTS=$(csa_add "$MDS_MOUNT_OPTS" -o rdonly_dev)
9417         OST_MOUNT_OPTS=$(csa_add "$OST_MOUNT_OPTS" -o rdonly_dev)
9418
9419         # Only restart server(mds/ost). Sufficient for test
9420         setupall server_only || error "Fail to start servers"
9421
9422         # Verify MDS's should be "ro"
9423         do_facet $SINGLEMDS mount | grep "lustre.*ro,.*MDT.*rdonly_dev" ||
9424                 error_113 "$SINGLEMDS should be read-only"
9425
9426         # Verify OST's should be "ro"
9427         for (( i=1; i <= OSTCOUNT; i++ )); do
9428                 do_facet ost$i mount | grep "lustre.*ro,.*OST.*rdonly_dev" ||
9429                         error_113 "ost$i should be read-only"
9430         done
9431 }
9432 run_test 113 "Shadow mountpoint correctly report ro/rw for mounts"
9433
9434 #
9435 # Purpose: To verify dynamic thread (OSS) creation.
9436 # (This was sanity/115)
9437 #
9438 test_114() {
9439         [ $PARALLEL == "yes" ] && skip "skip parallel run"
9440         remote_ost_nodsh && skip "remote OST with nodsh"
9441
9442         # Lustre does not stop service threads once they are started.
9443         # Reset number of running threads to default.
9444         stopall
9445         setupall
9446
9447         local OSTIO_pre
9448         local save_params="$TMP/sanity-$TESTNAME.parameters"
9449
9450         # Get ll_ost_io count before I/O
9451         OSTIO_pre=$(do_facet ost1 \
9452                 "$LCTL get_param ost.OSS.ost_io.threads_started | cut -d= -f2")
9453         # Exit if lustre is not running (ll_ost_io not running).
9454         [ -z "$OSTIO_pre" ] && error "no OSS threads"
9455
9456         echo "Starting with $OSTIO_pre threads"
9457         local thread_max=$((OSTIO_pre * 2))
9458         local rpc_in_flight=$((thread_max * 2))
9459
9460         # this is limited to OSC_MAX_RIF_MAX (256)
9461         [ $rpc_in_flight -gt 256 ] && rpc_in_flight=256
9462         thread_max=$((rpc_in_flight / 2))
9463         [ $thread_max -le $OSTIO_pre ] && skip "Too many ost_io threads" &&
9464                 return
9465
9466         # Number of I/O Process proposed to be started.
9467         local nfiles
9468         local facets=$(get_facets OST)
9469
9470         save_lustre_params client "osc.*OST*.max_rpcs_in_flight" > $save_params
9471         save_lustre_params $facets "ost.OSS.ost_io.threads_max" >> $save_params
9472
9473         # Set in_flight to $rpc_in_flight
9474         $LCTL set_param osc.*OST*.max_rpcs_in_flight=$rpc_in_flight ||
9475                 error "Failed to set max_rpcs_in_flight to $rpc_in_flight"
9476         nfiles=${rpc_in_flight}
9477         # Set ost thread_max to $thread_max
9478         do_facet ost1 "$LCTL set_param ost.OSS.ost_io.threads_max=$thread_max"
9479
9480         # 5 Minutes should be sufficient for max number of OSS
9481         # threads(thread_max) to be created.
9482         local timeout=300
9483
9484         # Start I/O.
9485         local wtl=${WTL:-"$LUSTRE/tests/write_time_limit"}
9486
9487         test_mkdir $DIR/$tdir
9488         for ((i = 1; i <= nfiles; i++)); do
9489                 local file=$DIR/$tdir/${tfile}-$i
9490
9491                 $LFS setstripe -c -1 -i 0 $file
9492                 ($wtl $file $timeout)&
9493         done
9494
9495         # I/O Started - Wait for thread_started to reach thread_max or report
9496         # error if thread_started is more than thread_max.
9497         echo "Waiting for thread_started to reach thread_max"
9498         local thread_started=0
9499         local end_time=$((SECONDS + timeout))
9500
9501         while [ $SECONDS -le $end_time ] ; do
9502                 echo -n "."
9503                 # Get ost i/o thread_started count.
9504                 thread_started=$(do_facet ost1 \
9505                         "$LCTL get_param \
9506                         ost.OSS.ost_io.threads_started | cut -d= -f2")
9507                 # Break out if thread_started is equal/greater than thread_max
9508                 if (( $thread_started >= $thread_max )); then
9509                         echo ll_ost_io thread_started $thread_started, \
9510                                 equal/greater than thread_max $thread_max
9511                         break
9512                 fi
9513                 sleep 1
9514         done
9515
9516         # Cleanup - We have the numbers, Kill i/o jobs if running.
9517         jobcount=($(jobs -p))
9518
9519         for ((i=0; i < ${#jobcount[*]}; i++)); do
9520                 kill -9 ${jobcount[$i]}
9521                 if [ $? -ne 0 ] ; then
9522                         echo "warning: cannot kill WTL pid ${jobcount[$i]}"
9523                 fi
9524         done
9525
9526         # Cleanup files left by WTL binary.
9527         for ((i = 1; i <= nfiles; i++)); do
9528                 local file=$DIR/$tdir/${tfile}-$i
9529
9530                 rm -rf $file
9531                 if [ $? -ne 0 ] ; then
9532                         echo "Warning: Failed to delete file $file"
9533                 fi
9534         done
9535
9536         restore_lustre_params <$save_params
9537         rm -f $save_params || echo "Warning: delete file '$save_params' failed"
9538
9539         # Error out if no new thread has started or Thread started is greater
9540         # than thread max.
9541         if (( $thread_started <= $OSTIO_pre ||
9542                 $thread_started > $thread_max )); then
9543                 error "ll_ost_io: thread_started $thread_started" \
9544                       "OSTIO_pre $OSTIO_pre, thread_max $thread_max." \
9545                       "No new thread started or thread started greater " \
9546                       "than thread_max."
9547         fi
9548 }
9549 run_test 114 "verify dynamic thread creation===================="
9550
9551 cleanup_115()
9552 {
9553         trap 0
9554         stopall
9555         do_facet mds1 rm -f $1
9556 }
9557
9558 test_115() {
9559         if [ "$mds1_FSTYPE" != ldiskfs ]; then
9560                 skip "Only applicable to ldiskfs-based MDTs"
9561         fi
9562         [ -n "$FILESET" ] && skip "Not functional for FILESET set"
9563
9564         local dbfs_ver=$(do_facet mds1 $DEBUGFS -V 2>&1)
9565
9566         echo "debugfs version: $dbfs_ver"
9567         echo "$dbfs_ver" | egrep -w "1.44.3.wc1|1.44.5.wc1|1.45.2.wc1" &&
9568                 skip_env "This version of debugfs doesn't show inode number"
9569
9570         local IMAGESIZE=$((3072 << 30)) # 3072 GiB
9571
9572         stopall
9573
9574         FLAKEY=false
9575
9576         echo "client1: "
9577         $LCTL dl
9578         mount | grep lustre
9579         echo "mds1: "
9580         do_facet mds1 "hostname; $LCTL dl; mount"
9581         echo "ost1: "
9582         do_facet ost1 "hostname; $LCTL dl; mount"
9583         # We need MDT size 3072GB, because it is smallest
9584         # partition that can store 2B inodes
9585         do_facet mds1 "mkdir -p $TMP/$tdir"
9586         local mdsimgname=$TMP/$tdir/lustre-mdt
9587
9588         do_facet mds1 "rm -f $mdsimgname"
9589         do_facet mds1 "touch $mdsimgname"
9590         stack_trap "cleanup_115 $mdsimgname" EXIT
9591         do_facet mds1 "$TRUNCATE $mdsimgname $IMAGESIZE" ||
9592                 skip "Backend FS doesn't support sparse files"
9593         local mdsdev=$(do_facet mds1 "losetup -f")
9594
9595         do_facet mds1 "losetup $mdsdev $mdsimgname"
9596
9597         local mds_opts="$(mkfs_opts mds1 $(mdsdevname 1))        \
9598                 --mkfsoptions='-O ea_inode,^resize_inode,meta_bg \
9599                 -N 2247484000 -E lazy_itable_init' --device-size=$IMAGESIZE"
9600         add mds1 $mds_opts --mgs --reformat $mdsdev || {
9601                 do_facet $SINGLEMDS \
9602                         "losetup -d $mdsdev && rm -f $mdsimgname"
9603                 skip_env "format large MDT failed"
9604         }
9605
9606         local ostdev=$(ostdevname 1)
9607
9608         local opts="$(mkfs_opts ost1 $ostdev) \
9609                 --reformat $ostdev $ostdev"
9610         add ost1 $opts || error "add ost1 failed with new params"
9611         start mds1  $mdsdev $MDS_MOUNT_OPTS || error "start MDS failed"
9612         start_ost || error "start OSS failed"
9613         mount_client $MOUNT || error "mount client failed"
9614
9615         mkdir -p $DIR/$tdir || error "mkdir $DIR/$tdir fail"
9616         local goal="/sys/fs/ldiskfs/$(basename $mdsdev)/inode_goal"
9617         echo goal: $goal
9618         # 2147483648 is 0x80000000
9619         do_facet mds1 "echo 2147483648 >> $goal; grep . $goal"
9620         touch $DIR/$tdir/$tfile
9621
9622         # attrs from 1 to 16 go to block, 17th - to inode
9623         local i
9624
9625         for i in {1..17}; do
9626                 local nm="trusted.ea$i"
9627                 setfattr -n $nm -v $(printf "xattr%0250d" $i) $DIR/$tdir/$tfile
9628         done
9629
9630         do_facet mds1 "$DEBUGFS -c -R 'stat ROOT/$tdir/$tfile' $mdsdev"
9631
9632         # inode <2147483649> trusted.ea16 (255)
9633         local inode_num=$(do_facet mds1 \
9634                         "$DEBUGFS -c -R 'stat ROOT/$tdir/$tfile' $mdsdev" |
9635                          awk '/ea17/ { print $2 }' |
9636                          sed -e 's/>//' -e 's/<//' -e 's/\"//')
9637         echo "inode num: $inode_num"
9638         [ $inode_num -ge 2147483648 ] || error "inode $inode_num too small"
9639         do_facet mds1 "losetup -d $mdsdev"
9640 }
9641 run_test 115 "Access large xattr with inodes number over 2TB"
9642
9643 test_116() {
9644         [ "$mds1_FSTYPE" != ldiskfs ] && skip "ldiskfs only test"
9645         [ "$MDS1_VERSION" -lt $(version_code 2.10.59) ] &&
9646                 skip "Need server version at least 2.10.59"
9647         do_facet $SINGLEMDS which mkfs.xfs ||
9648                 skip_env "No mkfs.xfs installed"
9649
9650         stopall
9651         load_modules
9652
9653         local tmpmnt=$TMP/$tdir
9654         local mdtimg=$tfile-mdt0
9655
9656         do_facet $SINGLEMDS mkdir -p $tmpmnt
9657         stack_trap "do_facet $SINGLEMDS rmdir $tmpmnt" EXIT
9658
9659         do_facet $SINGLEMDS touch $TMP/$mdtimg
9660         stack_trap "do_facet $SINGLEMDS rm -f $TMP/$mdtimg" EXIT
9661         do_facet $SINGLEMDS mkfs -t xfs -d file,size=1t,name=$TMP/$mdtimg ||
9662                 error "mkfs temporary xfs image"
9663
9664         do_facet $SINGLEMDS mount $TMP/$mdtimg $tmpmnt ||
9665                 error "mount temporary xfs image"
9666         stack_trap "do_facet $SINGLEMDS umount $tmpmnt" EXIT
9667         local old_mdssize=$MDSSIZE
9668         local old_mdsisize=$MDSISIZE
9669
9670         MDSSIZE=$((17 * 1024 * 1024 * 1024)) # 17T MDT
9671         MDSISIZE=$((16 << 20))
9672         local opts17t="$(mkfs_opts $SINGLEMDS)"
9673
9674         MDSSIZE=$old_mdssize
9675         MDSISIZE=$old_mdsisize
9676
9677         do_facet $SINGLEMDS $MKFS \
9678                 ${opts17t/-E /-E lazy_itable_init,lazy_journal_init,} \
9679                 $tmpmnt/$mdtimg ||
9680                 error "failed to mkfs for $tmpmnt/$mdtimg"
9681
9682         do_facet $SINGLEMDS $TUNE2FS -l $tmpmnt/$mdtimg |
9683                 grep -qw 'features.*extent' || error "extent should be enabled"
9684         reformat_and_config
9685 }
9686 run_test 116 "big size MDT support"
9687
9688 test_117() {
9689         # Call setup only if LustreFS is not mounted
9690         check_mount || setup
9691
9692         do_facet ost1 "$LCTL set_param ost.OSS.ost_io.nrs_policies=fifo"
9693         do_facet ost1 "$LCTL get_param -n ost.OSS.ost_io.nrs_tbf_rule" &&
9694                 error "get_param should fail"
9695         cleanup || error "cleanup failed with rc $?"
9696 }
9697 run_test 117 "lctl get_param return errors properly"
9698
9699 test_119() {
9700         local had_config
9701         local size_mb
9702
9703         [[ "$MDSCOUNT" -ge 2 ]] || skip "Need more at least 2 MDTs"
9704
9705         had_config=$(do_facet mds1 "$LCTL get_param debug | grep config")
9706         do_facet mds1 "$LCTL set_param debug=+config"
9707         do_facet mds1 "$LCTL clear"
9708
9709         setup
9710         do_facet mds2 "$TUNEFS --writeconf $(mdsdevname 2)" &>/dev/null
9711         # mount after writeconf will make "add osp" added to mdt0 config:
9712         # 53 (224)marker  60 (flags=0x01, v2.5.1.0) lustre-MDT0001  'add osp'
9713         # 54 (080)add_uuid  nid=...  0:  1:...
9714         # 55 (144)attach    0:lustre-MDT0001-osp-MDT0000  1:osp  2:...
9715         # 56 (144)setup     0:lustre-MDT0001-osp-MDT0000  1:...  2:...
9716         # 57 (136)modify_mdc_tgts add 0:lustre-MDT0000-mdtlov  1:...  2:1  3:1
9717         # duplicate modify_mdc_tgts caused crashes
9718
9719         debug_size_save
9720         # using larger debug_mb size to avoid lctl dk log truncation
9721         size_mb=$((DEBUG_SIZE_SAVED * 4))
9722         for i in {1..3}; do
9723                 stop_mdt 2
9724                 # though config processing stops after failed attach and setup
9725                 # it will proceed after the failed command after each writeconf
9726                 # this is the original scenario of the issue
9727                 do_facet mds2 "$TUNEFS --writeconf $(mdsdevname 2)" &>/dev/null
9728                 do_facet mds1 "$LCTL set_param debug_mb=$size_mb"
9729                 start_mdt 2
9730
9731                 wait_update_facet_cond mds1 \
9732                         "$LCTL dk | grep -c Processed.log.$FSNAME-MDT0000" \
9733                         ">" 1 300
9734         done
9735         debug_size_restore
9736
9737         [[ -z "$had_config" ]] && do_facet mds1 lctl set_param debug=-config
9738
9739         reformat
9740 }
9741 run_test 119 "writeconf on slave mdt shouldn't duplicate mdc/osp and crash"
9742
9743 test_120() { # LU-11130
9744         [ "$MDSCOUNT" -lt 2 ] && skip "mdt count < 2"
9745         [ "$mds1_FSTYPE" != ldiskfs ] &&
9746                 skip "ldiskfs only test"
9747         [ "$MDS1_VERSION" -lt $(version_code 2.11.56) ] &&
9748                 skip "Need DNE2 capable MD target with LU-11130 fix"
9749
9750         setup
9751
9752         local mds1host=$(facet_active_host mds1)
9753         local mds1dev=$(mdsdevname 1)
9754
9755         $LFS mkdir -i 1 $DIR/$tdir
9756         $LFS mkdir -i 0 $DIR/$tdir/mds1dir
9757
9758         ln -s foo $DIR/$tdir/bar
9759         mv $DIR/$tdir/bar $DIR/$tdir/mds1dir/bar2 ||
9760                 error "cross-target rename failed"
9761
9762         stopall
9763
9764         run_e2fsck $mds1host $mds1dev "-n"
9765 }
9766 run_test 120 "cross-target rename should not create bad symlinks"
9767
9768 test_121(){
9769         stopall
9770         start_mgsmds || error "MGS MDS Start failed"
9771         fail mgs
9772         stop_mds || error "Stopping MDSes failed"
9773         #failback
9774         start_mds
9775         fail mgs
9776         stop_mds || error "Stopping MDSes failed"
9777 }
9778 run_test 121 "failover MGS"
9779
9780 test_122a() {
9781         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
9782         [[ "$OST1_VERSION" -ge $(version_code 2.11.53) ]] ||
9783                 skip "Need OST version at least 2.11.53"
9784
9785         reformat
9786         LOAD_MODULES_REMOTE=true load_modules
9787 #define OBD_FAIL_OFD_SET_OID 0x1e0
9788         do_facet ost1 $LCTL set_param fail_loc=0x00001e0
9789
9790         setup_noconfig
9791         $LFS mkdir -i1 -c1 $DIR/$tdir
9792         $LFS setstripe -i0 -c1 $DIR/$tdir
9793         do_facet ost1 $LCTL set_param fail_loc=0
9794         createmany -o $DIR/$tdir/file_ 1000 ||
9795                 error "Fail to create a new sequence"
9796
9797         cleanup
9798 }
9799 run_test 122a "Check OST sequence update"
9800
9801 test_123aa() {
9802         remote_mgs_nodsh && skip "remote MGS with nodsh"
9803         [ -d $MOUNT/.lustre ] || setup
9804
9805         # test old logid format until removal from llog_ioctl.c::str2logid()
9806         if (( $MGS_VERSION < $(version_code 2.99.53) )); then
9807                 do_facet mgs $LCTL dl | grep MGS
9808                 do_facet mgs "$LCTL --device %MGS llog_print \
9809                               \\\\\\\$$FSNAME-client 1 10" ||
9810                         error "old llog_print failed"
9811         fi
9812
9813         # test new logid format
9814         if [ $MGS_VERSION -ge $(version_code 2.9.53) ]; then
9815                 do_facet mgs "$LCTL --device MGS llog_print $FSNAME-client" ||
9816                         error "new llog_print failed"
9817         fi
9818 }
9819 run_test 123aa "llog_print works with FIDs and simple names"
9820
9821 test_123ab() {
9822         remote_mgs_nodsh && skip "remote MGS with nodsh"
9823         [[ $MGS_VERSION -gt $(version_code 2.11.51) ]] ||
9824                 skip "Need server with working llog_print support"
9825
9826         [ -d $MOUNT/.lustre ] || setup
9827
9828         local yaml
9829         local orig_val
9830         local mgs_arg=""
9831
9832         [[ $MGS_VERSION -gt $(version_code 2.13.54) ]] ||
9833                 mgs_arg="--device MGS"
9834
9835         orig_val=$(do_facet mgs $LCTL get_param jobid_name)
9836         do_facet mgs $LCTL set_param -P jobid_name="TESTNAME"
9837
9838         yaml=$(do_facet mgs $LCTL $mgs_arg llog_print params |
9839                grep jobid_name | tail -n 1)
9840
9841         local param=$(awk '{ print $10 }' <<< "$yaml")
9842         local val=$(awk '{ print $12 }' <<< "$yaml")
9843         #return to the default
9844         do_facet mgs $LCTL set_param -P jobid_name=$orig_val
9845         [ $val = "TESTNAME" ] || error "bad value: $val"
9846         [ $param = "jobid_name," ] || error "Bad param: $param"
9847 }
9848 run_test 123ab "llog_print params output values from set_param -P"
9849
9850 test_123ac() { # LU-11566
9851         remote_mgs_nodsh && skip "remote MGS with nodsh"
9852         do_facet mgs "$LCTL help llog_print" 2>&1 | grep -q -- --start ||
9853                 skip "Need 'lctl llog_print --start' on MGS"
9854
9855         local start=10
9856         local end=50
9857         local mgs_arg=""
9858
9859         [[ $MGS_VERSION -gt $(version_code 2.13.54) ]] ||
9860                 mgs_arg="--device MGS"
9861
9862         [ -d $MOUNT/.lustre ] || setup
9863
9864         # - { index: 10, event: add_uuid, nid: 192.168.20.1@tcp(0x20000c0a81401,
9865         #     node: 192.168.20.1@tcp }
9866         do_facet mgs $LCTL $mgs_arg \
9867                 llog_print --start $start --end $end $FSNAME-client | tr -d , |
9868                 while read DASH BRACE INDEX idx EVENT BLAH BLAH BLAH; do
9869                 (( idx >= start )) || error "llog_print index $idx < $start"
9870                 (( idx <= end )) || error "llog_print index $idx > $end"
9871         done
9872 }
9873 run_test 123ac "llog_print with --start and --end"
9874
9875 test_123ad() { # LU-11566
9876         remote_mgs_nodsh && skip "remote MGS with nodsh"
9877         # older versions of lctl may not print all records properly
9878         do_facet mgs "$LCTL help llog_print" 2>&1 | grep -q -- --start ||
9879                 skip "Need 'lctl llog_print --start' on MGS"
9880
9881         [ -d $MOUNT/.lustre ] || setup
9882
9883         # append a new record, to avoid issues if last record was cancelled
9884         local old=$($LCTL get_param -n osc.*-OST0000-*.max_dirty_mb | head -1)
9885         do_facet mgs $LCTL conf_param $FSNAME-OST0000.osc.max_dirty_mb=$old
9886
9887         # logid:            [0x3:0xa:0x0]:0
9888         # flags:            4 (plain)
9889         # records_count:    72
9890         # last_index:       72
9891         local num=$(do_facet mgs $LCTL --device MGS llog_info $FSNAME-client |
9892                     awk '/last_index:/ { print $2 - 1 }')
9893
9894         # - { index: 71, event: set_timeout, num: 0x14, param: sys.timeout=20 }
9895         local last=$(do_facet mgs $LCTL --device MGS llog_print $FSNAME-client |
9896                      tail -1 | awk '{ print $4 }' | tr -d , )
9897         (( last == num )) || error "llog_print only showed $last/$num records"
9898 }
9899 run_test 123ad "llog_print shows all records"
9900
9901 test_123ae() { # LU-11566
9902         local max
9903         local mgs_arg=""
9904         local log
9905         local id
9906         local orig
9907         local new
9908
9909         remote_mgs_nodsh && skip "remote MGS with nodsh"
9910         [ -d $MOUNT/.lustre ] || setupall
9911
9912         max=$($LCTL get_param -n osc.*-OST0000-*.max_dirty_mb | head -1)
9913         pgs=$($LCTL get_param -n osc.*-OST0000-*.max_pages_per_rpc | head -1)
9914         [[ $MGS_VERSION -gt $(version_code 2.13.54) ]] ||
9915                 mgs_arg="--device MGS"
9916
9917         if do_facet mgs "$LCTL help llog_cancel" 2>&1| grep -q -- --log_id; then
9918                 # save one set_param -P record in case none exist
9919
9920                 do_facet mgs $LCTL set_param -P osc.*.max_pages_per_rpc=$pgs
9921                 stack_trap "do_facet mgs $LCTL set_param -P -d \
9922                                 osc.*.max_pages_per_rpc"
9923
9924                 log=params
9925                 orig=$(do_facet mgs $LCTL $mgs_arg llog_print $log |
9926                         tail -1 | awk '{ print $4 }' | tr -d , )
9927                 do_facet mgs $LCTL set_param -P osc.*.max_dirty_mb=$max
9928                 do_facet mgs $LCTL $mgs_arg llog_print $log | tail -1 |
9929                         grep "parameter: osc.*.max_dirty_mb" ||
9930                         error "new set_param -P wasn't stored in params log"
9931
9932                 # - { index: 71, event: set_param, device: general,
9933                 #     param: osc.*.max_dirty_mb, value: 256 }
9934                 id=$(do_facet mgs $LCTL $mgs_arg llog_print $log |
9935                      tail -1 | awk '{ print $4 }' | tr -d , )
9936                 do_facet mgs $LCTL $mgs_arg llog_cancel $log --log_idx=$id
9937                 local new=$(do_facet mgs $LCTL $mgs_arg llog_print $log |
9938                             tail -1 | awk '{ print $4 }' | tr -d , )
9939                 (( new == orig )) ||
9940                         error "new llog_cancel now $new, not at $orig records"
9941         fi
9942
9943         # test old positional parameters for a while still
9944         if [ "$MGS_VERSION" -le $(version_code 3.1.53) ]; then
9945                 log=$FSNAME-client
9946
9947                 do_facet mgs $LCTL conf_param \
9948                         $FSNAME-OST0000.osc.max_pages_per_rpc=$pgs
9949                 stack_trap "do_facet mgs $LCTL conf_param -d \
9950                                 $FSNAME-OST0000.osc.max_pages_per_rpc"
9951
9952                 orig=$(do_facet mgs $LCTL --device MGS llog_print $log |
9953                        tail -1 | awk '{ print $4 }' | tr -d , )
9954                 do_facet mgs $LCTL conf_param $FSNAME-OST0000.osc.max_dirty_mb=$max
9955                 do_facet mgs $LCTL --device MGS llog_print $log |
9956                         tail -1 | grep "parameter: osc.max_dirty_mb" ||
9957                         error "old conf_param wasn't stored in params log"
9958                 do_facet mgs $LCTL --device MGS llog_print $log
9959                 # - { index: 71, event: conf_param, device: testfs-OST0000-osc,
9960                 #     param: osc.max_dirty_mb=256 }
9961                 id=$(do_facet mgs $LCTL --device MGS llog_print $log |
9962                      tail -1 | awk '{ print $4 }' | tr -d , )
9963                 do_facet mgs $LCTL --device MGS llog_cancel $log $id
9964                 do_facet mgs $LCTL --device MGS llog_print $log
9965                 new=$(do_facet mgs $LCTL --device MGS llog_print $log |
9966                       tail -1 | awk '{ print $4 }' | tr -d , )
9967                 (( new == orig )) ||
9968                         error "old llog_cancel now $new, not at $orig records"
9969         fi
9970 }
9971 run_test 123ae "llog_cancel can cancel requested record"
9972
9973 test_123af() { #LU-13609
9974         [ "$MGS_VERSION" -ge $(version_code 2.13.54) -a \
9975            "$MDS1_VERSION" -ge $(version_code 2.13.54) ] ||
9976                 skip "Need both MGS and MDS version at least 2.13.54"
9977
9978         [ -d $MOUNT/.lustre ] || setupall
9979         stack_trap "do_facet mds1 $LCTL set_param fail_loc=0" EXIT
9980
9981         local device
9982         local facet
9983         local cmd
9984         local orig_clist
9985         local orig_count
9986         local new_clist
9987         local new_count
9988
9989         for device in "MGS" "$FSNAME-MDT0000"; do
9990                 cmd="--device $device llog_catlist"
9991                 echo "lctl $cmd ..."
9992                 if [ "$device" = "MGS" ]; then
9993                         facet="mgs"
9994                 else
9995                         facet="mds1"
9996                 fi
9997                 orig_clist=($(do_facet $facet $LCTL $cmd | awk '{ print $2 }'))
9998                 orig_count=${#orig_clist[@]}
9999                 echo "orig_clist: ${orig_clist[*]}"
10000
10001                 #define OBD_FAIL_CATLIST 0x131b
10002                 #fetch to llog records from the second one
10003                 do_facet $facet $LCTL set_param fail_loc=0x131b fail_val=2
10004
10005                 new_clist=($(do_facet $facet $LCTL $cmd | awk '{ print $2 }'))
10006                 new_count=${#new_clist[@]}
10007                 echo "new_clist: ${new_clist[*]}"
10008
10009                 [ $new_count -eq $((orig_count - 1)) ] ||
10010                         error "$new_count != $orig_count - 1"
10011                 for i in $(seq 0 $new_count); do
10012                         j=$((i + 1))
10013                         [ "${orig_clist[$j]}" = "${new_clist[$i]}" ] ||
10014                                 error "${orig_clist[$j]} != ${new_clist[$i]}"
10015                 done
10016                 do_facet mds1 $LCTL set_param fail_loc=0
10017                 echo "done"
10018         done
10019 }
10020 run_test 123af "llog_catlist can show all config files correctly"
10021
10022 test_123ag() { # LU-15142
10023         local rec
10024         local orig_val
10025
10026         remote_mgs_nodsh && skip "remote MGS with nodsh"
10027         (( $MGS_VERSION >= $(version_code 2.14.55) )) ||
10028                 skip "Need server version least 2.14.55"
10029
10030         [ -d $MOUNT/.lustre ] || setup
10031
10032         orig_val=$(do_facet mgs $LCTL get_param jobid_name)
10033         stack_trap "do_facet mgs $LCTL set_param -P jobid_name=$orig_val"
10034
10035         do_facet mgs $LCTL set_param -P jobid_name="TESTNAME1"
10036         do_facet mgs $LCTL set_param -P -d jobid_name
10037         rec=$(do_facet mgs $LCTL --device MGS llog_print params |
10038                 grep -c jobid_name)
10039         (( rec == 0 )) || error "parameter was not deleted, check #1"
10040         do_facet mgs $LCTL set_param -P jobid_name="TESTNAME1"
10041         rec=$(do_facet mgs $LCTL --device MGS llog_print params |
10042                 grep -c jobid_name)
10043         (( rec == 1)) || error "parameter is not set"
10044         # usage with ordinary set_param format works too
10045         do_facet mgs $LCTL set_param -P -d jobid_name="ANY"
10046         rec=$(do_facet mgs $LCTL --device MGS llog_print params |
10047                 grep -c jobid_name)
10048         (( rec == 0 )) || error "parameter was not deleted, check #2"
10049 }
10050 run_test 123ag "llog_print skips values deleted by set_param -P -d"
10051
10052 test_123ah() { #LU-7668 del_ost
10053         (( "$MGS_VERSION" >= $(version_code 2.15.51) &&
10054            "$MDS1_VERSION" >= $(version_code 2.15.51) )) ||
10055                 skip "Need MGS/MDS version >= 2.15.51 for del_ost"
10056
10057         [ -d $MOUNT/.lustre ] || setupall
10058         stack_trap "do_facet mds1 $LCTL set_param fail_loc=0" EXIT
10059
10060         local cmd="--device MGS llog_print"
10061
10062         cli_llogcnt_orig=$(do_facet mgs $LCTL $cmd $FSNAME-client |
10063                                 grep -c $FSNAME-OST0000)
10064         mds1_llogcnt_orig=$(do_facet mgs $LCTL $cmd $FSNAME-MDT0000 |
10065                                 grep -c $FSNAME-OST0000)
10066
10067         [ $cli_llogcnt_orig -gt 0 ] ||
10068                 error "$FSNAME-OST0000 not found (client)"
10069         [ $mds1_llogcnt_orig -gt 0 ] || error "$FSNAME-OST0000 not found (MDT)"
10070
10071         # -n/--dryrun should NOT modify catalog
10072         do_facet mgs "$LCTL del_ost -n -t $FSNAME-OST0000" ||
10073                 error "del_ost --dryrun failed with $?"
10074
10075         local cli_llogcnt=$(do_facet mgs $LCTL $cmd $FSNAME-client |
10076                         grep -c $FSNAME-OST0000)
10077         local mds1_llogcnt=$(do_facet mgs $LCTL $cmd $FSNAME-MDT0000 |
10078                         grep -c $FSNAME-OST0000)
10079
10080         [ $cli_llogcnt -eq $cli_llogcnt_orig ] ||
10081                 error "--dryrun error: $cli_llogcnt != $cli_llogcnt_orig"
10082         [ $mds1_llogcnt -eq $mds1_llogcnt_orig ] ||
10083                 error "--dryrun error: $mds1_llogcnt != $mds1_llogcnt_orig"
10084
10085         # actual run
10086         do_facet mgs "$LCTL del_ost --target $FSNAME-OST0000" ||
10087                 error "del_ost failed with $?"
10088
10089         local cli_llogcnt=$(do_facet mgs $LCTL $cmd $FSNAME-client |
10090                         grep -c $FSNAME-OST0000)
10091         local mds1_llogcnt=$(do_facet mgs $LCTL $cmd $FSNAME-MDT0000 |
10092                         grep -c $FSNAME-OST0000)
10093
10094         # every catalog entry for OST0000 should have been cancelled
10095         [ $cli_llogcnt -eq 0 ] || error "$FSNAME-OST0000 not cancelled (cli)"
10096         [ $mds1_llogcnt -eq 0 ] || error "$FSNAME-OST0000 not cancelled (MDT)"
10097
10098         umount_client $MOUNT
10099         mount_client $MOUNT
10100
10101         $LFS df | grep -q OST0000 && error "del_ost did not remove OST0000!"
10102         cleanup
10103         reformat_and_config
10104 }
10105 run_test 123ah "del_ost cancels config log entries correctly"
10106
10107 cleanup_123ai() {
10108         local timeout=$1
10109
10110         echo "cleanup test 123ai"
10111
10112         # cancel last timeout record
10113         do_facet mgs "$LCTL set_param -P -d timeout"
10114
10115         # restore timeout value
10116         do_nodes $(comma_list $(all_nodes)) "$LCTL set_param timeout=$timeout"
10117 }
10118
10119 test_123ai() { #LU-16167
10120         local i
10121         local count
10122         local old_count
10123         local old_timeout
10124
10125         remote_mgs_nodsh && skip "remote MGS with nodsh"
10126         (( MDS1_VERSION >= $(version_code 2.15.51) )) ||
10127                 skip "Need MDS version at least 2.15.51"
10128
10129         [ -d $MOUNT/.lustre ] || setup
10130
10131         old_count=$(do_facet mgs "$LCTL --device MGS llog_print -r params" |
10132                 grep -c "parameter: timeout")
10133
10134         old_timeout=$($LCTL get_param -n timeout)
10135         stack_trap "cleanup_123ai $old_timeout" EXIT
10136
10137         # add and cancel params (2 * MAX_IOC_BUFLEN / 128 + 1 = 129)
10138         for i in {1..129}; do
10139                 do_facet mgs "$LCTL set_param -P timeout=$i" ||
10140                         error "fail to set timeout=$i on MGS"
10141         done
10142
10143         count=$(do_facet mgs "$LCTL --device MGS llog_print -r params" |
10144                 grep -c "parameter: timeout")
10145
10146         ((count - old_count == 129)) ||
10147                 error "number timeout record missmatch ($count - $old_count != 129)"
10148
10149         do_facet mgs "$LCTL --device MGS llog_print params" |
10150                 tail -1 | grep  "timeout, value: 129" ||
10151                 error "llog_print could not display the last record (timeout=129)"
10152
10153 }
10154 run_test 123ai "llog_print display all non skipped records"
10155
10156 test_123_prep() {
10157         remote_mgs_nodsh && skip "remote MGS with nodsh"
10158
10159         [ -d $MOUNT/.lustre ] || setup
10160         yaml_file="$TMP/$tfile.yaml"
10161
10162         do_facet mgs rm "$yaml_file"
10163         cfgfiles=$(do_facet mgs "lctl --device MGS llog_catlist" |
10164                          sed 's/config_log://')
10165
10166         # set jobid_var to a different value for test
10167         orig_val=$(do_facet mgs $LCTL get_param jobid_var)
10168
10169         do_facet mgs $LCTL set_param -P jobid_var="TESTNAME"
10170
10171         for i in $cfgfiles params; do
10172                 do_facet mgs "lctl --device MGS llog_print ${i} >> $yaml_file"
10173         done
10174
10175         echo "Unmounting FS"
10176         stopall
10177         echo "Writeconf"
10178         writeconf_all
10179         echo "Remounting"
10180         setup_noconfig
10181 }
10182
10183 test_123_restore() {
10184         set_val=$(do_facet mgs $LCTL get_param jobid_var)
10185
10186         do_facet mgs $LCTL set_param -P $orig_val
10187
10188         [ $set_val == "jobid_var=TESTNAME" ] ||
10189                 error "$set_val is not TESTNAME"
10190
10191         do_facet mgs rm "$yaml_file"
10192         cleanup
10193 }
10194
10195 test_123F() {
10196         local yaml_file
10197         local cfgfiles
10198         local orig_val
10199         local set_val
10200
10201         test_123_prep
10202
10203         # Reapply the config from before
10204         echo "Setting configuration parameters"
10205         do_facet mgs "lctl set_param -F $yaml_file"
10206
10207         test_123_restore
10208 }
10209 run_test 123F "clear and reset all parameters using set_param -F"
10210
10211 test_123G() {
10212         local yaml_file
10213         local cfgfiles
10214         local orig_val
10215         local set_val
10216
10217         test_123_prep
10218
10219         # Reapply the config from before
10220         echo "Setting configuration parameters"
10221         do_facet mgs "lctl apply_yaml $yaml_file"
10222
10223         test_123_restore
10224 }
10225 run_test 123G "clear and reset all parameters using apply_yaml"
10226
10227
10228 test_124()
10229 {
10230         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
10231         [ -z $mds2failover_HOST ] && skip "needs MDT failover setup"
10232
10233         setup
10234         do_facet mgs $LCTL --device MGS llog_print $FSNAME-client |
10235                 grep 1.2.3.4@tcp && error "Should not be fake nid"
10236         do_facet mgs $LCTL conf_param $FSNAME-MDT0001.failover.node=1.2.3.4@tcp\
10237                 || error "Set params error"
10238         do_facet mgs $LCTL --device MGS llog_print $FSNAME-client |
10239                 grep 1.2.3.4@tcp || error "Fake nid should be added"
10240         cleanup
10241
10242         load_modules
10243         if combined_mgs_mds; then
10244                 start_mdt 1 "-o nosvc" ||
10245                         error "starting mds with nosvc option failed"
10246         fi
10247         local nid=$(do_facet mds2 $LCTL list_nids | head -1)
10248         local failover_nid=$(do_node $mds2failover_HOST $LCTL list_nids | head -1)
10249
10250         do_facet mgs $LCTL replace_nids $FSNAME-MDT0001 $nid:$failover_nid ||
10251                 error "replace_nids execution error"
10252
10253         if combined_mgs_mds; then
10254                 stop_mdt 1
10255         fi
10256
10257         setup
10258         fail mds2
10259         echo "lfs setdirstripe"
10260         $LFS setdirstripe -i 1 $MOUNT/$tdir || error "setdirstirpe error"
10261         echo ok
10262 }
10263 run_test 124 "check failover after replace_nids"
10264
10265 get_max_sectors_kb() {
10266         local facet="$1"
10267         local device="$2"
10268         local dev_base=$(basename $(do_facet ${facet} "readlink -f ${device}"))
10269         local max_sectors_path="/sys/block/${dev_base}/queue/max_sectors_kb"
10270
10271         do_facet ${facet} "[[ -e ${max_sectors_path} ]] &&
10272                            cat ${max_sectors_path}"
10273 }
10274
10275 get_max_hw_sectors_kb() {
10276         local facet="$1"
10277         local device="$2"
10278         local dev_base=$(basename $(do_facet ${facet} "readlink -f ${device}"))
10279         local max_hw_path="/sys/block/${dev_base}/queue/max_hw_sectors_kb"
10280
10281         do_facet ${facet} "[[ -e ${max_hw_path} ]] && cat ${max_hw_path}"
10282 }
10283
10284 set_max_sectors_kb() {
10285         local facet="$1"
10286         local device="$2"
10287         local value="$3"
10288         local dev_base=$(basename $(do_facet ${facet} "readlink -f ${device}"))
10289         local max_sectors_path="/sys/block/${dev_base}/queue/max_sectors_kb"
10290
10291         do_facet ${facet} "[[ -e ${max_sectors_path} ]] &&
10292                            echo ${value} > ${max_sectors_path}"
10293         rc=$?
10294
10295         [[ $rc -ne 0 ]] && echo "Failed to set ${max_sectors_path} to ${value}"
10296
10297         return $rc
10298 }
10299
10300 # Return 0 if all slave devices have max_sectors_kb == max_hw_sectors_kb
10301 # Otherwise return > 0
10302 check_slaves_max_sectors_kb()
10303 {
10304         local facet="$1"
10305         local device="$2"
10306         local dev_base=$(basename $(do_facet ${facet} "readlink -f ${device}"))
10307         local slaves_dir=/sys/block/${dev_base}/slaves
10308         local slave_devices=$(do_facet ${facet} "ls ${slaves_dir} 2>/dev/null")
10309         [[ -z ${slave_devices} ]] && return 0
10310
10311         local slave max_sectors new_max_sectors max_hw_sectors path
10312         local rc=0
10313
10314         for slave in ${slave_devices}; do
10315                 path="/dev/${slave}"
10316                 ! is_blkdev ${facet} ${path} && continue
10317                 max_sectors=$(get_max_sectors_kb ${facet} ${path})
10318                 max_hw_sectors=$(get_max_hw_sectors_kb ${facet} ${path})
10319                 new_max_sectors=${max_hw_sectors}
10320                 [[ ${new_max_sectors} -gt ${RQ_SIZE_LIMIT} ]] &&
10321                         new_max_sectors=${RQ_SIZE_LIMIT}
10322
10323                 if [[ ${max_sectors} -ne ${new_max_sectors} ]]; then
10324                         echo "${path} ${max_sectors} ${new_max_sectors}"
10325                         ((rc++))
10326                 fi
10327                 check_slaves_max_sectors_kb ${facet} ${path}
10328                 ((rc + $?))
10329         done
10330
10331         return $rc
10332 }
10333
10334 test_125()
10335 {
10336         local facet_list="mgs mds1 ost1"
10337         combined_mgs_mds && facet_list="mgs ost1"
10338
10339         local facet
10340         for facet in ${facet_list}; do
10341                 [[ $(facet_fstype ${facet}) != ldiskfs ]] &&
10342                         skip "ldiskfs only test" &&
10343                         return 0
10344                 ! is_blkdev ${facet} $(facet_device ${facet}) &&
10345                         skip "requires all real devices" &&
10346                         return 0
10347         done
10348
10349         local rc=0
10350         # We don't increase IO request size limit past 16MB. See comments in
10351         # lustre/utils/libmount_utils_ldiskfs.c:tune_max_sectors_kb()
10352         RQ_SIZE_LIMIT=$((16 * 1024))
10353         local device old_max_sectors new_max_sectors max_hw_sectors
10354         for facet in ${facet_list}; do
10355                 device=$(facet_device ${facet})
10356                 old_max_sectors=$(get_max_sectors_kb ${facet} ${device})
10357                 max_hw_sectors=$(get_max_hw_sectors_kb ${facet} ${device})
10358
10359                 # The expected value after l_tunedisk is executed
10360                 new_max_sectors=$old_max_sectors
10361                 [[ ${new_max_sectors_kb} -gt ${RQ_SIZE_LIMIT} ]] &&
10362                         new_max_sectors_kb=${RQ_SIZE_LIMIT}
10363
10364                 # Ensure the current value of max_sectors_kb does not equal
10365                 # max_hw_sectors_kb, so we can tell whether l_tunedisk did
10366                 # anything
10367                 set_max_sectors_kb ${facet} ${device} $((new_max_sectors - 1))
10368
10369                 # Value before l_tunedisk
10370                 local pre_max_sectors=$(get_max_sectors_kb ${facet} ${device})
10371                 if [[ ${pre_max_sectors} -ne $((new_max_sectors - 1)) ]]; then
10372                         echo "unable to satsify test pre-condition:"
10373                         echo "${pre_max_sectors} != $((new_max_sectors - 1))"
10374                         ((rc++))
10375                         continue
10376                 fi
10377
10378                 echo "Before: ${facet} ${device} ${pre_max_sectors} ${max_hw_sectors}"
10379
10380                 do_facet ${facet} "l_tunedisk ${device}"
10381
10382                 # Value after l_tunedisk
10383                 local post_max_sectors=$(get_max_sectors_kb ${facet} ${device})
10384
10385                 echo "After: ${facet} ${device} ${post_max_sectors} ${max_hw_sectors}"
10386
10387                 if [[ ${facet} != ost1 ]]; then
10388                         if [[ ${post_max_sectors} -ne ${pre_max_sectors} ]]; then
10389                                 echo "l_tunedisk modified max_sectors_kb of ${facet}"
10390                                 ((rc++))
10391                         fi
10392
10393                         set_max_sectors_kb ${facet} ${device} ${old_max_sectors}
10394                 else
10395                         if [[ ${post_max_sectors} -eq ${pre_max_sectors} ]]; then
10396                                 echo "l_tunedisk failed to modify max_sectors_kb of ${facet}"
10397                                 ((rc++))
10398                         fi
10399
10400                         check_slaves_max_sectors_kb ${facet} ${device} ||
10401                                 ((rc++))
10402                 fi
10403         done
10404
10405         return $rc
10406 }
10407 run_test 125 "check l_tunedisk only tunes OSTs and their slave devices"
10408
10409 test_126() {
10410         [[ "$MDS1_VERSION" -ge $(version_code 2.13.52) ]] ||
10411                 skip "Need MDS version at least 2.13.52"
10412
10413         cleanup
10414         do_rpc_nodes $(facet_active_host $SINGLEMDS) load_module ../libcfs/libcfs/libcfs
10415         #define OBD_FAIL_OBD_SETUP 0x60d
10416         do_facet mds1 $LCTL set_param fail_loc=0x60d
10417         do_rpc_nodes $(facet_active_host $SINGLEMDS) load_modules &
10418         for i in {1..40}; do
10419                 do_facet mds1 lsmod | grep -q osd_$mds1_FSTYPE && break
10420                 sleep 1
10421         done
10422         clear_failloc $SINGLEMDS 20 &
10423         start mds1 $(mdsdevname 1) $MDS_MOUNT_OPTS
10424 }
10425 run_test 126 "mount in parallel shouldn't cause a crash"
10426
10427 test_127() {
10428         [[ "$ost1_FSTYPE" == ldiskfs ]] || skip "ldiskfs only test"
10429
10430         cleanup
10431         setup
10432         zconf_umount_clients $RCLIENTS $MOUNT
10433
10434         wait_osp_active ost ${FSNAME}-OST0000 0 1
10435         local osc_tgt="$FSNAME-OST0000-osc-$($LFS getname -i $DIR)"
10436         local avail1=($($LCTL get_param -n osc.${osc_tgt}.kbytesavail))
10437
10438         $LFS setstripe -i 0 $DIR/$tfile || error "failed creating $DIR/$tfile"
10439         dd if=/dev/zero of=$DIR/$tfile bs=1M oflag=direct || true
10440
10441         local avail2=($($LCTL get_param -n osc.${osc_tgt}.kbytesavail))
10442
10443         if ((avail2 * 100 / avail1 > 1)); then
10444                 lfs df $DIR
10445                 ls -l $DIR/$tfile
10446                 error "more than 1% space left: before=$avail1 after=$avail2"
10447         fi
10448
10449         local mbs=$(($(stat -c %s $DIR/$tfile) / (1024 * 1024)))
10450
10451         dd if=/dev/zero of=$DIR/$tfile bs=1M count=$mbs conv=notrunc \
10452                 oflag=direct || error "overwrite failed"
10453 }
10454 run_test 127 "direct io overwrite on full ost"
10455
10456 test_128()
10457 {
10458         combined_mgs_mds && skip "need separate mgs device"
10459         [ "$ost2_FSTYPE" == zfs ] && import_zpool ost2
10460
10461         format_ost 2
10462         # Try to apply nolocallogs to the virgin OST. Should fail.
10463         do_facet ost2 "$TUNEFS --nolocallogs $(ostdevname 2)" &&
10464                 error "nolocallogs should not be allowed on the virgin target"
10465
10466         setupall
10467         stopall
10468
10469         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
10470         # Start OST without MGS (local configs)
10471         do_facet ost1 "$TUNEFS --dryrun $(ostdevname 1)"
10472         start_ost || error "unable to start OST1"
10473         stop_ost || error "Unable to stop OST1"
10474
10475         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
10476         # Do not allow reading local configs, should fail
10477         do_facet ost1 "$TUNEFS --nolocallogs $(ostdevname 1)" ||
10478                 error "Can not set nolocallogs"
10479         start_ost && error "OST1 started, but should fail"
10480
10481         # Connect to MGS successfully, reset nolocallogs flag
10482         [ "$ost1_FSTYPE" == zfs ] && import_zpool ost1
10483         start_mgs || error "unable to start MGS"
10484         start_ost || error "unable to start OST1"
10485
10486         do_facet ost1 "$TUNEFS --dryrun $(ostdevname 1)" | grep "nolocallogs" &&
10487                 error "nolocallogs expected to be reset"
10488
10489         stop_ost || error "Unable to stop OST1"
10490 }
10491 run_test 128 "Force using remote logs with --nolocallogs"
10492
10493 test_129()
10494 {
10495         (( MDS1_VERSION >= $(version_code 2.14.57) )) ||
10496                 skip "Need MDS version at least 2.14.57"
10497         stopall
10498         start_mgsmds || error "MGS/MDS start failed"
10499         format_ost 1
10500         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS &&
10501                 error "start ost1 should fail" || true
10502         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS &&
10503                 error "second start ost1 should fail" || true
10504         do_facet ost1 "$TUNEFS --writeconf $(ostdevname 1)"
10505         start ost1 $(ostdevname 1) $OST_MOUNT_OPTS ||
10506                 error "start ost1 failed"
10507         stop ost1
10508         stop_mds
10509 }
10510 run_test 129 "attempt to connect an OST with the same index should fail"
10511
10512 test_130()
10513 {
10514         [ $MDSCOUNT -lt 2 ] && skip "needs >= 2 MDTs"
10515         setupall
10516         stop_mdt 2 || error "mdt2 stop failed"
10517         do_facet mds2 "$TUNEFS --writeconf $(mdsdevname 2)"
10518         start_mdt 2 || error "mdt2 start failed"
10519         do_facet mds2 "$LCTL dl" | grep MDT0001-osp-MDT0001 &&
10520                 error "Illegal OSP device created" || true
10521 }
10522 run_test 130 "re-register an MDT after writeconf"
10523
10524 test_131() {
10525         [ "$mds1_FSTYPE" == "ldiskfs" ] || skip "ldiskfs only test"
10526         (( $MDS1_VERSION >= $(version_code 2.14.56.35) )) ||
10527                 skip "Need MDS version at least 2.14.56.35"
10528         do_facet mds1 $DEBUGFS -R features $(mdsdevname 1) |
10529                 grep -q project || skip "skip project quota not supported"
10530
10531         local projid
10532
10533         setupall
10534         test_mkdir -c $MDSCOUNT -p $DIR/$tdir
10535         $LFS project -p 1000 $DIR/$tdir || error "set dir project id failed"
10536         createmany -o $DIR/$tdir/f 512
10537         for ((i = 0; i < 512; ++i)); do
10538                 $LFS project -p $i $DIR/$tdir/f${i} ||
10539                         error "set f${i} project id failed"
10540         done
10541
10542         test_mkdir -c $MDSCOUNT -p $DIR/$tdir.inherit
10543         $LFS project -p 1001 -s $DIR/$tdir.inherit
10544         createmany -o $DIR/$tdir.inherit/f 128
10545         (( $($LFS project $DIR/$tdir.inherit/f* |
10546                 awk '$1 == 1001 { print }' | wc -l) == 128 )) ||
10547                         error "files did not inherit projid 1001"
10548
10549         stopall
10550
10551         for i in $(seq $MDSCOUNT); do
10552                 mds_backup_restore mds$i ||
10553                         error "Backup/restore on mds$i failed"
10554         done
10555
10556         setupall
10557
10558         projid=($($LFS project -d $DIR/$tdir))
10559         [ ${projid[0]} == "1000" ] ||
10560                 error "projid expected 1000 not ${projid[0]}"
10561         for ((i = 0; i < 512; ++i)); do
10562                 projid=($($LFS project $DIR/$tdir/f${i}))
10563                 [ ${projid[0]} == "$i" ] ||
10564                         error "projid expected $i not ${projid[0]}"
10565         done
10566
10567         (( $($LFS project $DIR/$tdir.inherit/f* |
10568                 awk '$1 == 1001 { print }' | wc -l) == 128 )) ||
10569                         error "restore did not copy projid 1001"
10570 }
10571 run_test 131 "MDT backup restore with project ID"
10572
10573 test_132() {
10574         local err_cnt
10575         local err_cnt2
10576
10577         (( MDS1_VERSION >= $(version_code 2.14.57) )) ||
10578                 skip "Need MDS version at least 2.14.57"
10579         reformat
10580         combined_mgs_mds || start_mgs || error "unable to start MGS"
10581         start_mdt 1 || error "unable to start mdt1"
10582
10583         err_cnt=$(do_facet mds1 dmesg | grep -c "cannot take the layout locks")
10584         stop_mdt 1 || error "stop mdt1 failed"
10585
10586         [ "$mds1_FSTYPE" == zfs ] && import_zpool mds1
10587         do_facet mds1 $TUNEFS --param mdt.hsm_control=enabled $(mdsdevname 1) ||
10588                 error "tunefs failed"
10589         start_mdt 1 || error "cannot start mdt1"
10590
10591         err_cnt2=$(do_facet mds1 dmesg | grep -c "cannot take the layout locks")
10592         [ $err_cnt -eq $err_cnt2 ] || error "Can not take the layout lock"
10593         stop_mdt 1 || error "stop mdt1 failed"
10594 }
10595 run_test 132 "hsm_actions processed after failover"
10596
10597 # This test verifies we do RR allocation within a pool even if there is a
10598 # significant imbalance vs an OST outside the pool
10599 test_133() {
10600         [[ $OSTCOUNT -lt 4 ]] && skip_env "needs >= 4 OSTs"
10601         [[ "$OST1_VERSION" -ge $(version_code 2.15.51) ]] ||
10602                 skip "Need OST version at least 2.15.51"
10603         # This is the easiest way to ensure OSTs start out balanced
10604         reformat_and_config
10605         setupall
10606
10607         check_set_fallocate_or_skip
10608
10609         local testfile=$DIR/$tdir/$tfile
10610         local pool="testpool"
10611         local ostrange=$((OSTCOUNT - 1))
10612         # Select all but the last OST to add to the pool
10613         local poolostrange=$((OSTCOUNT - 2))
10614         local filenum=20
10615         local filecount
10616         local stripecount
10617
10618         declare -a AVAIL
10619         free_min_max
10620
10621         [ $MINV -eq 0 ] && error "no free space in OST$MINI"
10622         [ $MAXV -gt $((2 * $MINV)) ] &&
10623                 error "OSTs badly unbalanced after reformat"
10624
10625         create_pool $FSNAME.$pool || error "failed to create a pool"
10626         do_facet mgs $LCTL pool_add $FSNAME.$pool OST[0-$poolostrange] ||
10627                 error "failed to add OST[0-$poolostrange] to the pool"
10628
10629         test_mkdir -p $DIR/$tdir || error "failed to mkdir $DIR/$tdir"
10630         # Consume space on the OSTs in the pool so they are unbalanced with the
10631         # OST outside of the pool
10632         # fill each OST 90% with fallocate so they are widely
10633         # imbalanced
10634         local size=$(((MINV * 9 / 10) * 1024))
10635         for ((i = 0; i <= poolostrange; i++)); do
10636                 $LFS setstripe -c 1 -i $i $testfile$i ||
10637                         error "failed to setstripe $testfile$i"
10638                 fallocate -l $size $testfile$i || error "fallocate failed"
10639         done
10640         ls -la $DIR/$tdir
10641         sleep_maxage
10642         $LFS df
10643
10644         # Create files in the pool now that there is an imbalance
10645         filecount=$(((OSTCOUNT - 1) * filenum))
10646         for ((i = 0; i < filecount; i++)); do
10647                 $LFS setstripe -p $pool $testfile-$i ||
10648                         error "failed to setstripe -p $pool $testfile-$i"
10649         done
10650         $LFS getstripe -i $testfile-* > /tmp/$tfile.log
10651         # Count the number of files with a stripe on each OST to verify the
10652         # pool allocated with round-robin
10653         for ((i = 0; i <= poolostrange; i++)); do
10654                 stripecount=$(grep -c $i /tmp/$tfile.log)
10655                 # Allow a little leeway
10656                 if (( stripecount < filenum - 1 ||
10657                       stripecount > filenum + 1 )); then
10658                         cat /tmp/$tfile.log
10659                         error "$stripecount != $filenum files on OST$i"
10660                 fi
10661         done
10662
10663         # Create files across the system now that there is an imbalance
10664         filecount=$((OSTCOUNT * filenum))
10665         for ((i = 1; i < filecount; i++)); do
10666                 $LFS setstripe $testfile-$i.2 ||
10667                         error "failed to setstripe $testilfe-$i.2"
10668         done
10669         $LFS getstripe -i $testfile-*.2 > /tmp/$tfile.log
10670         local qos_used=""
10671         # Count the number of files with a stripe on each OST to verify the
10672         # files are *NOT* allocated with round-robin
10673         for ((i = 0; i <= ostrange; i++)); do
10674                 stripecount=$(grep -c $i /tmp/$tfile.log)
10675                 if [[ $stripecount -ne $filenum ]]; then
10676                         qos_used="true"
10677                         echo "QOS: $stripecount != $filenum files on OST$i"
10678                 fi
10679         done
10680         if [ -z "$qos_used" ]; then
10681                 error "QOS not used on imbalanced OSTs!"
10682         fi
10683
10684         rm -rf /tmp/$tfile.log $DIR/$tdir
10685         do_facet mgs $LCTL pool_remove $FSNAME.$pool OST[0-$poolostrange] ||
10686                 "failed to remove OST[0-$poolostrange] from the pool"
10687         do_facet mgs $LCTL pool_destroy $FSNAME.$pool ||
10688                 error "failed to destroy pool"
10689 }
10690 run_test 133 "stripe QOS: free space balance in a pool"
10691
10692 test_134() {
10693         [ "$mds1_FSTYPE" == "ldiskfs" ] || skip "ldiskfs only test"
10694         local errors
10695         local rc
10696         local mdt_dev=$(facet_device mds1)
10697         local tmp_dir=$TMP/$tdir
10698         local out=$tmp_dir/check_iam.txt
10699         local CHECK_IAM=${CHECK_IAM:-$(do_facet mds1 "which check_iam 2> /dev/null || true")}
10700
10701         [[ -n "$CHECK_IAM" ]] || skip "check_iam not found"
10702
10703         mkdir -p $tmp_dir
10704         for ((i=0; i<64; i++)); do
10705                 local f=oi.16.$i
10706                 #cmd introduce a random corruption to IAM file
10707                 local cmd="dd if=/dev/urandom of=$tmp_dir/$f bs=2 conv=notrunc count=1 seek=$((RANDOM % 36))"
10708                 do_facet mds1 "mkdir -p $tmp_dir; \
10709                    $DEBUGFS -c -R 'dump $f $tmp_dir/$f' $mdt_dev 2>&1; \
10710                    $CHECK_IAM -v $tmp_dir/$f 2>&1; \
10711                    echo $cmd; eval $cmd 2>/dev/null;
10712                    $CHECK_IAM -v $tmp_dir/$f 2>&1; echo \\\$?" >> $out 2>&1
10713         done
10714
10715         tail -n50 $out
10716
10717         stack_trap "rm -rf $tmp_dir && do_facet mds1 rm -rf $tmp_dir" EXIT
10718
10719         rc=$(grep -c "fault\|except" $out)
10720         (( rc == 0 )) || { cat $out &&
10721                 error "check_iam failed with fault or exception $rc"; }
10722
10723         rc=$(grep -c "^255" $out)
10724         errors=$(grep -c "FINISHED WITH ERRORS" $out)
10725
10726         (( rc == errors )) || { cat $out &&
10727                 error "check_iam errcode does not fit with errors $rc $errors"; }
10728 }
10729 run_test 134 "check_iam works without faults"
10730
10731 cleanup_test_135(){
10732         local oldgc=$1
10733
10734         printf "\nCleanup test_135\n" >&2
10735         do_facet mds1 "$LCTL set_param -n $oldgc"
10736         rm -rf $DIR/$tdir &> /dev/null
10737         cleanup
10738 }
10739
10740 __test_135_file_thread() {
10741         local service="$1"
10742         local init_time=$(awk '{print $1}' /proc/uptime)
10743         local awkcmd="/crosses index zero/ {if (\$1 > $init_time) exit(1);}"
10744
10745         #Generate a full plain llogs
10746         while dmesg | sed -r 's/(\[|\])//g' | awk "$awkcmd" ; do
10747                 createmany -o $DIR/$tdir/f 4500 >&2
10748                 createmany -u $DIR/$tdir/f 4500 >&2
10749         done
10750 }
10751
10752 __test_135_reader() {
10753         local fd=$1
10754         local cl_user=$2
10755         local firstidx=$(changelog_user_rec mds1 $cl_user)
10756         local oldidx=$firstidx
10757         local newidx=0
10758         local pid=0
10759         local other
10760
10761         while read -t10 -u$fd newidx other; do
10762                 (( (newidx - oldidx) == 1 )) ||
10763                         error  "changelog jump detected (last: $oldidx, current: $newidx)"
10764
10765                 if (( (newidx - firstidx + 1) % 13000 == 0 )); then
10766                         [[ $pid -eq 0 ]] ||
10767                                 wait $pid || error "changelog_clear failed"
10768                         changelog_clear $((newidx - 1)) mds1 >&2 & pid=$!
10769                 fi
10770                 oldidx=$newidx
10771         done
10772
10773         [[ $pid -eq 0 ]] ||
10774                 wait $pid || error "changelog_clear failed"
10775
10776         echo "$oldidx"
10777 }
10778
10779 test_135() {
10780         (( MDS1_VERSION >= $(version_code 2.15.52) )) ||
10781                 skip "need MDS version at least 2.15.52"
10782
10783         local service=$(facet_svc mds1)
10784         local rc=0
10785         local lastread lastidx
10786         local files_pid reader_pid
10787         local fd
10788         local init_time
10789         local cl_user
10790
10791         # Need to reformat because we are changing llog catalog sizes to 5.
10792         # Otherwise, processing could fail with existing catalogs (last_idx>5).
10793         reformat
10794         setup_noconfig
10795
10796         # Disable changelog garbage colector
10797         local oldgc=$(do_facet mds1 "$LCTL get_param mdd.${service}.changelog_gc")
10798         do_facet mds1 "$LCTL set_param -n mdd.${service}.changelog_gc=0"
10799         stack_trap "cleanup_test_135 $oldgc" EXIT INT
10800
10801         # change the changelog_catalog size to 5 entries for everybody
10802 #define OBD_FAIL_CAT_RECORDS                        0x1312
10803         do_node $(comma_list $(all_nodes)) $LCTL set_param fail_loc=0x1312 fail_val=5
10804
10805         # disable console ratelimit
10806         local rl=$(cat /sys/module/libcfs/parameters/libcfs_console_ratelimit)
10807         echo 0 > /sys/module/libcfs/parameters/libcfs_console_ratelimit
10808         stack_trap "echo $rl > /sys/module/libcfs/parameters/libcfs_console_ratelimit" EXIT
10809
10810         test_mkdir -c 1 -i 0 $DIR/$tdir || error "Failed to create directory"
10811         changelog_chmask "ALL" || error "changelog_chmask failed"
10812         changelog_register || error "changelog_register failed"
10813
10814         cl_user="${CL_USERS[mds1]%% *}"
10815         changelog_users mds1 | grep -q $cl_user ||
10816                 error "User $cl_user not found in changelog_users"
10817
10818         # Start reader thread
10819         coproc $LFS changelog --follow $service
10820         reader_pid=$!
10821         fd=${COPROC[0]}
10822         stack_trap "echo kill changelog reader; kill $reader_pid" EXIT
10823
10824         echo -e "\nWrap arround changelog catalog"
10825
10826         # Start file writer thread
10827         __test_135_file_thread "$service" & files_pid=$!
10828         stack_trap "(pkill -P$files_pid; kill $files_pid) &> /dev/null || true" EXIT
10829
10830         # Check changelog entries
10831         lastread=$(__test_135_reader $fd $cl_user) || exit $?
10832         ! kill -0 $files_pid 2>/dev/null ||
10833                 error "creation thread is running. Is changelog reader stuck?"
10834
10835         lastidx=$(changelog_users mds1 | awk '/current_index/ {print $NF}' )
10836         [[ "$lastread" -eq "$lastidx" ]] ||
10837                 error "invalid changelog lastidx (read: $lastread, mds: $lastidx)"
10838 }
10839 run_test 135 "check the behavior when changelog is wrapped around"
10840
10841 cleanup_136 () {
10842         do_facet mds2 "$LCTL --device ec cleanup" || true
10843         do_facet mds2 "$LCTL --device ec detach" || true
10844
10845         stopall
10846         reformat_and_config
10847 }
10848
10849 test_136() {
10850         (( MDSCOUNT >= 2 )) || skip "needs >= 2 MDTs"
10851
10852         reformat
10853         setup_noconfig
10854
10855         do_facet mds2 "$LCTL attach echo_client ec ec_uuid" ||
10856             error "echo attach fail"
10857
10858         stack_trap cleanup_136 EXIT
10859
10860         do_facet mds2 "$LCTL --device ec setup lustre-MDT0001 mdt" &&
10861             error "attach to MDT should fail!"
10862
10863         do_facet mds2 "$LCTL --device ec setup lustre-MDT0001 mdd" ||
10864             error "attach to MDD should OK"
10865         do_facet mds2 "$LCTL --device ec test_mkdir /tt" &&
10866             error "mkdir test should fail with remote object"
10867
10868         return 0
10869 }
10870 run_test 136 "don't panic with bad obdecho setup"
10871
10872 test_140() {
10873         (( MDS1_VERSION >= $(version_code 2.15.55) )) ||
10874                 skip "need MDS version at least 2.15.55"
10875         (( MDSCOUNT >= 2 )) || skip "needs >= 2 MDTs"
10876
10877         RM_UPDATELOG=$(do_facet mds2 "which remove_updatelog 2> /dev/null")
10878         RM_UPDATELOG=${RM_UPDATELOG:-"$LUSTRE/scripts/remove_updatelog"}
10879
10880         [ -f "$RM_UPDATELOG" ] ||
10881                 skip_env "remove_updatelog is not found on mds2"
10882
10883         local mntpt=$(facet_mntpt mds2)
10884
10885         setup_noconfig
10886         test_mkdir -c $MDSCOUNT -p $DIR/$tdir ||
10887                 error "mkdir $DIR/$tdir failed"
10888         mkdir $DIR/$tdir/d{1..256}
10889
10890         stop_mdt 1
10891         stop_mdt 2
10892
10893         mount_fstype mds2 || error "mount as fstype mds2 failed"
10894         do_facet mds2 $RM_UPDATELOG -n $mntpt
10895         MDTS=($(do_facet mds2 $RM_UPDATELOG -n $mntpt |
10896                 grep -o "Processing MDT[0-9]*" | awk -F'MDT' '{print $2}'))
10897         (( ${#MDTS[@]} == MDSCOUNT )) ||
10898                 error "Processed ${#MDTS[@]} from $MDSCOUNT"
10899
10900         do_facet mds2 $RM_UPDATELOG -n -m 1,0 $mntpt
10901         MDTS=($(do_facet mds2 $RM_UPDATELOG -n -m 1,0 $mntpt |
10902                 grep -o "Processing MDT[0-9]*" | awk -F'MDT' '{print $2}'))
10903         (( ${#MDTS[@]} == 2 )) ||
10904                 error "Processed ${#MDTS[@]} instead of 2"
10905         (( ${MDTS[0]} == 1 && ${MDTS[1]} == 0 )) ||
10906                 error "Processed: ${MDTS[*]}, expected: 1 0"
10907
10908         do_facet mds2 $RM_UPDATELOG -m 0 $mntpt
10909         unmount_fstype mds2
10910         start_mdt 2 || error "mds2 start fail"
10911         start_mdt 1 || error "mds1 start fail"
10912         wait_clients_import_state ${CLIENTS:-$HOSTNAME} mds1 FULL
10913         wait_clients_import_state ${CLIENTS:-$HOSTNAME} mds2 FULL
10914
10915         rm -rf $DIR/$tdir || error "Can't remove $tdir"
10916         stopall
10917         reformat_and_config
10918 }
10919 run_test 140 "remove_updatelog script actions"
10920
10921 test_150() {
10922         setup
10923
10924         local max_cached_mb=$($LCTL get_param llite.*.max_cached_mb |
10925                               awk '/^max_cached_mb/ { print $2 }')
10926         stack_trap "$LCTL set_param -n llite.*.max_cached_mb=$max_cached_mb"
10927
10928         $LCTL set_param llite.*.max_cached_mb='100%'
10929
10930         local new_max_cached_mb=$($LCTL get_param llite.*.max_cached_mb |
10931                                   awk '/^max_cached_mb/ { print $2 }')
10932         local total_ram_mb=$(free -m | grep 'Mem:' | awk '{print $2}')
10933
10934         $LCTL get_param llite.*.max_cached_mb
10935         echo "total ram mb: $total_ram_mb"
10936         (( new_max_cached_mb == total_ram_mb )) ||
10937                 error "setting cache to 100% not equal to total RAM"
10938
10939         $LCTL set_param llite.*.max_cached_mb='50%'
10940         new_max_cached_mb=$($LCTL get_param llite.*.max_cached_mb |
10941                             awk '/^max_cached_mb/ { print $2 }')
10942
10943         $LCTL get_param llite.*.max_cached_mb
10944         (( new_max_cached_mb == $((total_ram_mb / 2)) )) ||
10945                 error "setting cache to 50% not equal to 50% of RAM"
10946
10947         $LCTL set_param llite.*.max_cached_mb='105%' &&
10948                 error "should not be able to set insane value"
10949
10950         $LCTL set_param llite.*.max_cached_mb='0%'
10951         new_max_cached_mb=$($LCTL get_param llite.*.max_cached_mb |
10952                             awk '/^max_cached_mb/ { print $2 }')
10953         # Minimum cache size is 64 MiB
10954         $LCTL get_param llite.*.max_cached_mb
10955         (( new_max_cached_mb == 64 )) ||
10956                 error "setting cache to 0% != minimum cache size"
10957 }
10958 run_test 150 "test setting max_cached_mb to a %"
10959
10960 test_151() {
10961         (( MDS1_VERSION >= $(version_code 2.15.58) )) ||
10962                 skip "need MDS version at least 2.15.58"
10963         [[ "$ost1_FSTYPE" == ldiskfs ]] || skip "ldiskfs only test"
10964
10965         cleanup
10966         if ! combined_mgs_mds ; then
10967                 stop mgs
10968         fi
10969
10970         echo "Damage ost1 local config log"
10971         do_facet ost1 "$DEBUGFS -w -R 'punch CONFIGS/$FSNAME-OST0000 0 1' \
10972                       $(ostdevname 1) || return \$?" ||
10973                 error "do_facet ost1 failed with $?"
10974
10975         # expect OST to fail mount with no MGS and bad local config
10976         start_ost && error "OST start should fail"
10977
10978         if ! combined_mgs_mds ; then
10979                 start_mgs
10980         fi
10981         start_mds || error "MDS start failed"
10982         # now it should start with MGS config
10983         start_ost || error "OST start failed"
10984         reformat_and_config
10985 }
10986 run_test 151 "damaged local config doesn't prevent mounting"
10987
10988 test_152() {
10989         (( MDS1_VERSION >= $(version_code 2.15.59.53) )) ||
10990                 skip "need MDS >= 2.15.59.53 for sequence allocation retry"
10991         (( MDSCOUNT >= 2 )) || skip "needs >= 2 MDTs"
10992         local tf=$DIR/$tdir/$tfile
10993         local nost=$((OSTCOUNT+1))
10994         local nostdevname=$(ostdevname $nost)
10995
10996         setupall
10997         test_mkdir -i 1 -c1 $DIR/$tdir || error "can't mkdir"
10998
10999         log "ADD OST$nost"
11000         add ost$nost $(mkfs_opts ost1 $nostdevname) --index=$nost \
11001                 --reformat $nostdevname $(ostvdevname $nost)
11002         [[ -d "$nostdevname" ]] || stack_trap "do_facet mds1 rm -f $nostdevname"
11003
11004 #define OBD_FAIL_OPS_FAIL_SEQ_ALLOC             0x2109
11005         do_facet mds1 $LCTL set_param fail_loc=0x80002109 fail_val=2
11006         echo "START OST$nost"
11007         stack_trap "stop ost$nost"
11008         start ost$nost $nostdevname $OST_MOUNT_OPTS &
11009         local PID=$!
11010         sleep 2
11011
11012         $LFS setstripe -c -1 $tf &
11013         local PID2=$!
11014         sleep 2
11015
11016         log "STOP OST$nost"
11017         # probably mount hasn't completed yet, so stop races with it
11018         while true; do
11019                 stop ost$nost
11020                 jobs -pr | grep -E "^$PID\$" && sleep 0.5 && continue
11021                 break
11022         done
11023         wait $PID
11024         wait $PID2
11025         do_facet mds1 $LCTL set_param fail_loc=0
11026         log "START OST$nost again"
11027         start ost$nost $nostdevname $OST_MOUNT_OPTS ||
11028                 error "can't start ost$nost"
11029         sleep 10
11030         $LFS setstripe -c -1 $tf-2 || error "can't touch  $tf-2"
11031         $LFS getstripe -v $tf-2
11032         local stripes=$($LFS getstripe -c $tf-2)
11033         (( stripes == $nost )) || error "$tf-2 $stripes != $nost"
11034 }
11035 run_test 152 "seq allocation error in OSP"
11036
11037 test_153a() {
11038         reformat_and_config
11039
11040         start_mds || error "MDS start failed"
11041         start_ost || error "OST start failed"
11042
11043         local nid=$($LCTL list_nids | grep ${NETTYPE} | head -n1)
11044         local net=${nid#*@}
11045         local MGS_NID=$(do_facet mgs $LCTL list_nids | head -1)
11046         local OST1_NID=$(do_facet ost1 $LCTL list_nids | head -1)
11047         local FAKE_PNID="192.168.252.112@${net}"
11048         local FAKE_NIDS="${FAKE_PNID},${FAKE_PNID}2"
11049         local FAKE_FAILOVER="10.252.252.113@${net},10.252.252.113@${net}2"
11050         local NIDS_AND_FAILOVER="$FAKE_NIDS:$FAKE_FAILOVER:$OST1_NID:$MGS_NID"
11051         local period=0
11052         local pid
11053         local rc
11054
11055         mount -t lustre $NIDS_AND_FAILOVER:/lustre $MOUNT &
11056         pid=$!
11057         while (( period < 30 )); do
11058                 [[ -n "$(ps -p $pid -o pid=)" ]] || break
11059                 echo "waiting for mount ..."
11060                 sleep 5
11061                 period=$((period + 5))
11062         done
11063         $LCTL get_param mgc.MGC${FAKE_PNID}.import | grep "uptodate:"
11064         check_mount || error "check_mount failed"
11065         umount $MOUNT
11066         cleanup || error "cleanup failed with rc $?"
11067 }
11068 run_test 153a "bypass invalid NIDs quickly"
11069
11070 #
11071 # (This was sanity/802a)
11072 #
11073 saved_MGS_MOUNT_OPTS=$MGS_MOUNT_OPTS
11074 saved_MDS_MOUNT_OPTS=$MDS_MOUNT_OPTS
11075 saved_OST_MOUNT_OPTS=$OST_MOUNT_OPTS
11076 saved_MOUNT_OPTS=$MOUNT_OPTS
11077
11078 cleanup_802a() {
11079         stopall
11080         MGS_MOUNT_OPTS=$saved_MGS_MOUNT_OPTS
11081         MDS_MOUNT_OPTS=$saved_MDS_MOUNT_OPTS
11082         OST_MOUNT_OPTS=$saved_OST_MOUNT_OPTS
11083         MOUNT_OPTS=$saved_MOUNT_OPTS
11084         setupall
11085 }
11086
11087 test_802a() {
11088         [[ $mds1_FSTYPE = zfs ]] || skip "ZFS specific test"
11089         [[ $MDS1_VERSION -lt $(version_code 2.9.55) ]] ||
11090         [[ $OST1_VERSION -lt $(version_code 2.9.55) ]] &&
11091                 skip "Need server version at least 2.9.55"
11092
11093         [[ $ENABLE_QUOTA ]] && skip "Quota enabled for read-only test"
11094
11095         # Reset before starting
11096         stopall
11097         setupall
11098
11099         mkdir $DIR/$tdir || error "(1) fail to mkdir"
11100
11101         cp $LUSTRE/tests/test-framework.sh $DIR/$tdir/ ||
11102                 error "(2) Fail to copy"
11103
11104         stack_trap cleanup_802a EXIT
11105
11106         # sync by force before remount as readonly
11107         sync; sync_all_data; sleep 3; sync_all_data
11108
11109         stopall
11110
11111         MGS_MOUNT_OPTS=$(csa_add "$MGS_MOUNT_OPTS" -o rdonly_dev)
11112         MDS_MOUNT_OPTS=$(csa_add "$MDS_MOUNT_OPTS" -o rdonly_dev)
11113         OST_MOUNT_OPTS=$(csa_add "$OST_MOUNT_OPTS" -o rdonly_dev)
11114
11115         echo "Mount the server as read only"
11116         setupall server_only || error "(3) Fail to start servers"
11117
11118         echo "Mount client without ro should fail"
11119         mount_client $MOUNT &&
11120                 error "(4) Mount client without 'ro' should fail"
11121
11122         echo "Mount client with ro should succeed"
11123         MOUNT_OPTS=$(csa_add "$MOUNT_OPTS" -o ro)
11124         mount_client $MOUNT ||
11125                 error "(5) Mount client with 'ro' should succeed"
11126
11127         echo "Modify should be refused"
11128         touch $DIR/$tdir/guard && error "(6) Touch should fail under ro mode"
11129
11130         echo "Read should be allowed"
11131         diff $LUSTRE/tests/test-framework.sh $DIR/$tdir/test-framework.sh ||
11132                 error "(7) Read should succeed under ro mode"
11133 }
11134 run_test 802a "simulate readonly device"
11135
11136 if ! combined_mgs_mds ; then
11137         stop mgs
11138 fi
11139
11140 cleanup_gss
11141
11142 # restore the values of MDSSIZE and OSTSIZE
11143 MDSSIZE=$STORED_MDSSIZE
11144 OSTSIZE=$STORED_OSTSIZE
11145 reformat
11146
11147 complete_test $SECONDS
11148 check_and_cleanup_lustre
11149 exit_status