lustre/tests/sanity-sec.sh

   1 #!/bin/bash
   2 #
   3 # Run select tests by setting ONLY, or as arguments to the script.
   4 # Skip specific tests by setting EXCEPT.
   5 #
   6
   7 set -e
   8
   9 ONLY=${ONLY:-"$*"}
  10 # bug number for skipped test:
  11 ALWAYS_EXCEPT="              $SANITY_SEC_EXCEPT"
  12 if $SHARED_KEY; then
  13 # bug number for skipped test: 9145 9145 9671 9145 9145 9145 9145 9245
  14         ALWAYS_EXCEPT="        17   18   19   20   21   22   23   27 $ALWAYS_EXCEPT"
  15 fi
  16 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  17
  18 SRCDIR=$(dirname $0)
  19 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin
  20 export NAME=${NAME:-local}
  21
  22 LUSTRE=${LUSTRE:-$(dirname $0)/..}
  23 . $LUSTRE/tests/test-framework.sh
  24 init_test_env $@
  25 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  26 init_logging
  27
  28 NODEMAP_TESTS=$(seq 7 26)
  29
  30 if ! check_versions; then
  31         echo "It is NOT necessary to test nodemap under interoperation mode"
  32         EXCEPT="$EXCEPT $NODEMAP_TESTS"
  33 fi
  34
  35 [ "$SLOW" = "no" ] && EXCEPT_SLOW="26"
  36
  37 [ "$ALWAYS_EXCEPT$EXCEPT$EXCEPT_SLOW" ] &&
  38         echo "Skipping tests: $ALWAYS_EXCEPT $EXCEPT $EXCEPT_SLOW"
  39
  40 RUNAS_CMD=${RUNAS_CMD:-runas}
  41
  42 WTL=${WTL:-"$LUSTRE/tests/write_time_limit"}
  43
  44 CONFDIR=/etc/lustre
  45 PERM_CONF=$CONFDIR/perm.conf
  46 FAIL_ON_ERROR=false
  47
  48 HOSTNAME_CHECKSUM=$(hostname | sum | awk '{ print $1 }')
  49 SUBNET_CHECKSUM=$(expr $HOSTNAME_CHECKSUM % 250 + 1)
  50 NODEMAP_COUNT=16
  51 NODEMAP_RANGE_COUNT=3
  52 NODEMAP_IPADDR_LIST="1 10 64 128 200 250"
  53 NODEMAP_MAX_ID=128
  54
  55 require_dsh_mds || exit 0
  56 require_dsh_ost || exit 0
  57
  58 clients=${CLIENTS//,/ }
  59 num_clients=$(get_node_count ${clients})
  60 clients_arr=($clients)
  61
  62 ID0=${ID0:-500}
  63 ID1=${ID1:-501}
  64 USER0=$(getent passwd | grep :$ID0:$ID0: | cut -d: -f1)
  65 USER1=$(getent passwd | grep :$ID1:$ID1: | cut -d: -f1)
  66
  67 [ -z "$USER0" ] &&
  68         skip "need to add user0 ($ID0:$ID0)" && exit 0
  69
  70 [ -z "$USER1" ] &&
  71         skip "need to add user1 ($ID1:$ID1)" && exit 0
  72
  73 IDBASE=${IDBASE:-60000}
  74
  75 # changes to mappings must be reflected in test 23
  76 FOPS_IDMAPS=(
  77         [0]="$((IDBASE+3)):$((IDBASE+0)) $((IDBASE+4)):$((IDBASE+2))"
  78         [1]="$((IDBASE+5)):$((IDBASE+1)) $((IDBASE+6)):$((IDBASE+2))"
  79         )
  80
  81 check_and_setup_lustre
  82
  83 sec_cleanup() {
  84         if [ "$I_MOUNTED" = "yes" ]; then
  85                 cleanupall -f || error "sec_cleanup"
  86         fi
  87 }
  88
  89 DIR=${DIR:-$MOUNT}
  90 [ -z "$(echo $DIR | grep $MOUNT)" ] &&
  91         error "$DIR not in $MOUNT" && sec_cleanup && exit 1
  92
  93 [ $(echo $MOUNT | wc -w) -gt 1 ] &&
  94         echo "NAME=$MOUNT mounted more than once" && sec_cleanup && exit 0
  95
  96 # for GSS_SUP
  97 GSS_REF=$(lsmod | grep ^ptlrpc_gss | awk '{print $3}')
  98 if [ ! -z "$GSS_REF" -a "$GSS_REF" != "0" ]; then
  99         GSS_SUP=1
 100         echo "with GSS support"
 101 else
 102         GSS_SUP=0
 103         echo "without GSS support"
 104 fi
 105
 106 MDT=$(do_facet $SINGLEMDS lctl get_param -N "mdt.\*MDT0000" |
 107         cut -d. -f2 || true)
 108 [ -z "$MDT" ] && error "fail to get MDT device" && exit 1
 109 do_facet $SINGLEMDS "mkdir -p $CONFDIR"
 110 IDENTITY_FLUSH=mdt.$MDT.identity_flush
 111 IDENTITY_UPCALL=mdt.$MDT.identity_upcall
 112
 113 SAVE_PWD=$PWD
 114
 115 build_test_filter
 116
 117 sec_login() {
 118         local user=$1
 119         local group=$2
 120
 121         $GSS_KRB5 || return
 122         if ! $RUNAS_CMD -u $user krb5_login.sh; then
 123                 error "$user login kerberos failed."
 124                 exit 1
 125         fi
 126
 127         if ! $RUNAS_CMD -u $user -g $group ls $DIR > /dev/null 2>&1; then
 128                 $RUNAS_CMD -u $user lfs flushctx -k
 129                 $RUNAS_CMD -u $user krb5_login.sh
 130                 if ! $RUNAS_CMD -u$user -g$group ls $DIR > /dev/null 2>&1; then
 131                         error "init $user $group failed."
 132                         exit 2
 133                 fi
 134         fi
 135 }
 136
 137 declare -a identity_old
 138
 139 sec_setup() {
 140         for num in $(seq $MDSCOUNT); do
 141                 switch_identity $num true || identity_old[$num]=$?
 142         done
 143
 144         if ! $RUNAS_CMD -u $ID0 ls $DIR > /dev/null 2>&1; then
 145                 sec_login $USER0 $USER0
 146         fi
 147
 148         if ! $RUNAS_CMD -u $ID1 ls $DIR > /dev/null 2>&1; then
 149                 sec_login $USER1 $USER1
 150         fi
 151 }
 152 sec_setup
 153
 154 # run as different user
 155 test_0() {
 156         umask 0022
 157
 158         chmod 0755 $DIR || error "chmod (1)"
 159         rm -rf $DIR/$tdir || error "rm (1)"
 160         mkdir -p $DIR/$tdir || error "mkdir (1)"
 161         chown $USER0 $DIR/$tdir || error "chown (2)"
 162         $RUNAS_CMD -u $ID0 ls $DIR || error "ls (1)"
 163         rm -f $DIR/f0 || error "rm (2)"
 164         $RUNAS_CMD -u $ID0 touch $DIR/f0 && error "touch (1)"
 165         $RUNAS_CMD -u $ID0 touch $DIR/$tdir/f1 || error "touch (2)"
 166         $RUNAS_CMD -u $ID1 touch $DIR/$tdir/f2 && error "touch (3)"
 167         touch $DIR/$tdir/f3 || error "touch (4)"
 168         chown root $DIR/$tdir || error "chown (3)"
 169         chgrp $USER0 $DIR/$tdir || error "chgrp (1)"
 170         chmod 0775 $DIR/$tdir || error "chmod (2)"
 171         $RUNAS_CMD -u $ID0 touch $DIR/$tdir/f4 || error "touch (5)"
 172         $RUNAS_CMD -u $ID1 touch $DIR/$tdir/f5 && error "touch (6)"
 173         touch $DIR/$tdir/f6 || error "touch (7)"
 174         rm -rf $DIR/$tdir || error "rm (3)"
 175 }
 176 run_test 0 "uid permission ============================="
 177
 178 # setuid/gid
 179 test_1() {
 180         [ $GSS_SUP = 0 ] && skip "without GSS support." && return
 181
 182         rm -rf $DIR/$tdir
 183         mkdir -p $DIR/$tdir
 184
 185         chown $USER0 $DIR/$tdir || error "chown (1)"
 186         $RUNAS_CMD -u $ID1 -v $ID0 touch $DIR/$tdir/f0 && error "touch (2)"
 187         echo "enable uid $ID1 setuid"
 188         do_facet $SINGLEMDS "echo '* $ID1 setuid' >> $PERM_CONF"
 189         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 190         $RUNAS_CMD -u $ID1 -v $ID0 touch $DIR/$tdir/f1 || error "touch (3)"
 191
 192         chown root $DIR/$tdir || error "chown (4)"
 193         chgrp $USER0 $DIR/$tdir || error "chgrp (5)"
 194         chmod 0770 $DIR/$tdir || error "chmod (6)"
 195         $RUNAS_CMD -u $ID1 -g $ID1 touch $DIR/$tdir/f2 && error "touch (7)"
 196         $RUNAS_CMD -u$ID1 -g$ID1 -j$ID0 touch $DIR/$tdir/f3 && error "touch (8)"
 197         echo "enable uid $ID1 setuid,setgid"
 198         do_facet $SINGLEMDS "echo '* $ID1 setuid,setgid' > $PERM_CONF"
 199         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 200         $RUNAS_CMD -u $ID1 -g $ID1 -j $ID0 touch $DIR/$tdir/f4 ||
 201                 error "touch (9)"
 202         $RUNAS_CMD -u $ID1 -v $ID0 -g $ID1 -j $ID0 touch $DIR/$tdir/f5 ||
 203                 error "touch (10)"
 204
 205         rm -rf $DIR/$tdir
 206
 207         do_facet $SINGLEMDS "rm -f $PERM_CONF"
 208         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 209 }
 210 run_test 1 "setuid/gid ============================="
 211
 212 # bug 3285 - supplementary group should always succeed.
 213 # NB: the supplementary groups are set for local client only,
 214 # as for remote client, the groups of the specified uid on MDT
 215 # will be obtained by upcall /sbin/l_getidentity and used.
 216 test_4() {
 217         local server_version=$(lustre_version_code $SINGLEMDS)
 218
 219         [[ $server_version -ge $(version_code 2.6.93) ]] ||
 220         [[ $server_version -ge $(version_code 2.5.35) &&
 221            $server_version -lt $(version_code 2.5.50) ]] ||
 222                 { skip "Need MDS version at least 2.6.93 or 2.5.35"; return; }
 223
 224         rm -rf $DIR/$tdir
 225         mkdir -p $DIR/$tdir
 226         chmod 0771 $DIR/$tdir
 227         chgrp $ID0 $DIR/$tdir
 228         $RUNAS_CMD -u $ID0 ls $DIR/$tdir || error "setgroups (1)"
 229         do_facet $SINGLEMDS "echo '* $ID1 setgrp' > $PERM_CONF"
 230         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 231         $RUNAS_CMD -u $ID1 -G1,2,$ID0 ls $DIR/$tdir ||
 232                 error "setgroups (2)"
 233         $RUNAS_CMD -u $ID1 -G1,2 ls $DIR/$tdir && error "setgroups (3)"
 234         rm -rf $DIR/$tdir
 235
 236         do_facet $SINGLEMDS "rm -f $PERM_CONF"
 237         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 238 }
 239 run_test 4 "set supplementary group ==============="
 240
 241 create_nodemaps() {
 242         local i
 243         local out
 244         local rc
 245
 246         squash_id default 99 0
 247         squash_id default 99 1
 248         for (( i = 0; i < NODEMAP_COUNT; i++ )); do
 249                 local csum=${HOSTNAME_CHECKSUM}_${i}
 250
 251                 if ! do_facet mgs $LCTL nodemap_add $csum; then
 252                         return 1
 253                 fi
 254
 255                 out=$(do_facet mgs $LCTL get_param nodemap.$csum.id)
 256                 ## This needs to return zero if the following statement is 1
 257                 [[ $(echo $out | grep -c $csum) == 0 ]] && return 1
 258         done
 259         return 0
 260 }
 261
 262 delete_nodemaps() {
 263         local i
 264         local out
 265
 266         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 267                 local csum=${HOSTNAME_CHECKSUM}_${i}
 268
 269                 if ! do_facet mgs $LCTL nodemap_del $csum; then
 270                         error "nodemap_del $csum failed with $?"
 271                         return 3
 272                 fi
 273
 274                 out=$(do_facet mgs $LCTL get_param nodemap.$csum.id)
 275                 [[ $(echo $out | grep -c $csum) != 0 ]] && return 1
 276         done
 277         return 0
 278 }
 279
 280 add_range() {
 281         local j
 282         local cmd="$LCTL nodemap_add_range"
 283         local range
 284         local rc=0
 285
 286         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 287                 range="$SUBNET_CHECKSUM.${2}.${j}.[1-253]@tcp"
 288                 if ! do_facet mgs $cmd --name $1 --range $range; then
 289                         rc=$((rc + 1))
 290                 fi
 291         done
 292         return $rc
 293 }
 294
 295 delete_range() {
 296         local j
 297         local cmd="$LCTL nodemap_del_range"
 298         local range
 299         local rc=0
 300
 301         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 302                 range="$SUBNET_CHECKSUM.${2}.${j}.[1-253]@tcp"
 303                 if ! do_facet mgs $cmd --name $1 --range $range; then
 304                         rc=$((rc + 1))
 305                 fi
 306         done
 307
 308         return $rc
 309 }
 310
 311 add_idmaps() {
 312         local i
 313         local cmd="$LCTL nodemap_add_idmap"
 314         local rc=0
 315
 316         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 317                 local j
 318
 319                 for ((j = 500; j < NODEMAP_MAX_ID; j++)); do
 320                         local csum=${HOSTNAME_CHECKSUM}_${i}
 321                         local client_id=$j
 322                         local fs_id=$((j + 1))
 323
 324                         if ! do_facet mgs $cmd --name $csum --idtype uid \
 325                              --idmap $client_id:$fs_id; then
 326                                 rc=$((rc + 1))
 327                         fi
 328                         if ! do_facet mgs $cmd --name $csum --idtype gid \
 329                              --idmap $client_id:$fs_id; then
 330                                 rc=$((rc + 1))
 331                         fi
 332                 done
 333         done
 334
 335         return $rc
 336 }
 337
 338 delete_idmaps() {
 339         local i
 340         local cmd="$LCTL nodemap_del_idmap"
 341         local rc=0
 342
 343         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 344                 local j
 345
 346                 for ((j = 500; j < NODEMAP_MAX_ID; j++)); do
 347                         local csum=${HOSTNAME_CHECKSUM}_${i}
 348                         local client_id=$j
 349                         local fs_id=$((j + 1))
 350
 351                         if ! do_facet mgs $cmd --name $csum --idtype uid \
 352                              --idmap $client_id:$fs_id; then
 353                                 rc=$((rc + 1))
 354                         fi
 355                         if ! do_facet mgs $cmd --name $csum --idtype gid \
 356                              --idmap $client_id:$fs_id; then
 357                                 rc=$((rc + 1))
 358                         fi
 359                 done
 360         done
 361
 362         return $rc
 363 }
 364
 365 modify_flags() {
 366         local i
 367         local proc
 368         local option
 369         local cmd="$LCTL nodemap_modify"
 370         local rc=0
 371
 372         proc[0]="admin_nodemap"
 373         proc[1]="trusted_nodemap"
 374         option[0]="admin"
 375         option[1]="trusted"
 376
 377         for ((idx = 0; idx < 2; idx++)); do
 378                 if ! do_facet mgs $cmd --name $1 --property ${option[$idx]} \
 379                      --value 1; then
 380                         rc=$((rc + 1))
 381                 fi
 382
 383                 if ! do_facet mgs $cmd --name $1 --property ${option[$idx]} \
 384                      --value 0; then
 385                         rc=$((rc + 1))
 386                 fi
 387         done
 388
 389         return $rc
 390 }
 391
 392 squash_id() {
 393         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 394                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 395                 return
 396         local cmd
 397
 398         cmd[0]="$LCTL nodemap_modify --property squash_uid"
 399         cmd[1]="$LCTL nodemap_modify --property squash_gid"
 400
 401         if ! do_facet mgs ${cmd[$3]} --name $1 --value $2; then
 402                 return 1
 403         fi
 404 }
 405
 406 # ensure that the squash defaults are the expected defaults
 407 squash_id default 99 0
 408 squash_id default 99 1
 409
 410 test_nid() {
 411         local cmd
 412
 413         cmd="$LCTL nodemap_test_nid"
 414
 415         nid=$(do_facet mgs $cmd $1)
 416
 417         if [ $nid == $2 ]; then
 418                 return 0
 419         fi
 420
 421         return 1
 422 }
 423
 424 test_idmap() {
 425         local i
 426         local cmd="$LCTL nodemap_test_id"
 427         local rc=0
 428
 429         ## nodemap deactivated
 430         if ! do_facet mgs $LCTL nodemap_activate 0; then
 431                 return 1
 432         fi
 433         for ((id = 500; id < NODEMAP_MAX_ID; id++)); do
 434                 local j
 435
 436                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 437                         local nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 438                         local fs_id=$(do_facet mgs $cmd --nid $nid      \
 439                                       --idtype uid --id $id)
 440                         if [ $fs_id != $id ]; then
 441                                 echo "expected $id, got $fs_id"
 442                                 rc=$((rc + 1))
 443                         fi
 444                 done
 445         done
 446
 447         ## nodemap activated
 448         if ! do_facet mgs $LCTL nodemap_activate 1; then
 449                 return 2
 450         fi
 451
 452         for ((id = 500; id < NODEMAP_MAX_ID; id++)); do
 453                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 454                         nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 455                         fs_id=$(do_facet mgs $cmd --nid $nid    \
 456                                 --idtype uid --id $id)
 457                         expected_id=$((id + 1))
 458                         if [ $fs_id != $expected_id ]; then
 459                                 echo "expected $expected_id, got $fs_id"
 460                                 rc=$((rc + 1))
 461                         fi
 462                 done
 463         done
 464
 465         ## trust client ids
 466         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 467                 local csum=${HOSTNAME_CHECKSUM}_${i}
 468
 469                 if ! do_facet mgs $LCTL nodemap_modify --name $csum \
 470                      --property trusted --value 1; then
 471                         error "nodemap_modify $csum failed with $?"
 472                         return 3
 473                 fi
 474         done
 475
 476         for ((id = 500; id < NODEMAP_MAX_ID; id++)); do
 477                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 478                         nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 479                         fs_id=$(do_facet mgs $cmd --nid $nid    \
 480                                 --idtype uid --id $id)
 481                         if [ $fs_id != $id ]; then
 482                                 echo "expected $id, got $fs_id"
 483                                 rc=$((rc + 1))
 484                         fi
 485                 done
 486         done
 487
 488         ## ensure allow_root_access is enabled
 489         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 490                 local csum=${HOSTNAME_CHECKSUM}_${i}
 491
 492                 if ! do_facet mgs $LCTL nodemap_modify --name $csum     \
 493                      --property admin --value 1; then
 494                         error "nodemap_modify $csum failed with $?"
 495                         return 3
 496                 fi
 497         done
 498
 499         ## check that root allowed
 500         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 501                 nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 502                 fs_id=$(do_facet mgs $cmd --nid $nid --idtype uid --id 0)
 503                 if [ $fs_id != 0 ]; then
 504                         echo "root allowed expected 0, got $fs_id"
 505                         rc=$((rc + 1))
 506                 fi
 507         done
 508
 509         ## ensure allow_root_access is disabled
 510         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 511                 local csum=${HOSTNAME_CHECKSUM}_${i}
 512
 513                 if ! do_facet mgs $LCTL nodemap_modify --name $csum     \
 514                                 --property admin --value 0; then
 515                         error "nodemap_modify ${HOSTNAME_CHECKSUM}_${i} "
 516                                 "failed with $rc"
 517                         return 3
 518                 fi
 519         done
 520
 521         ## check that root is mapped to 99
 522         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 523                 nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 524                 fs_id=$(do_facet mgs $cmd --nid $nid --idtype uid --id 0)
 525                 if [ $fs_id != 99 ]; then
 526                         error "root squash expected 99, got $fs_id"
 527                         rc=$((rc + 1))
 528                 fi
 529         done
 530
 531         ## reset client trust to 0
 532         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 533                 if ! do_facet mgs $LCTL nodemap_modify          \
 534                         --name ${HOSTNAME_CHECKSUM}_${i}        \
 535                         --property trusted --value 0; then
 536                         error "nodemap_modify ${HOSTNAME_CHECKSUM}_${i} "
 537                                 "failed with $rc"
 538                         return 3
 539                 fi
 540         done
 541
 542         return $rc
 543 }
 544
 545 test_7() {
 546         local rc
 547
 548         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 549         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 550                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 551                 return
 552
 553         create_nodemaps
 554         rc=$?
 555         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 556
 557         delete_nodemaps
 558         rc=$?
 559         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 2
 560
 561         return 0
 562 }
 563 run_test 7 "nodemap create and delete"
 564
 565 test_8() {
 566         local rc
 567
 568         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 569         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 570                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 571                 return
 572
 573         # Set up nodemaps
 574
 575         create_nodemaps
 576         rc=$?
 577         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 578
 579         # Try duplicates
 580
 581         create_nodemaps
 582         rc=$?
 583         [[ $rc == 0 ]] && error "duplicate nodemap_add allowed with $rc" &&
 584         return 2
 585
 586         # Clean up
 587         delete_nodemaps
 588         rc=$?
 589         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 3
 590
 591         return 0
 592 }
 593 run_test 8 "nodemap reject duplicates"
 594
 595 test_9() {
 596         local i
 597         local rc
 598
 599         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 600         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 601                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 602                 return
 603
 604         rc=0
 605         create_nodemaps
 606         rc=$?
 607         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 608
 609         rc=0
 610         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 611                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 612                         rc=$((rc + 1))
 613                 fi
 614         done
 615         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 616
 617         rc=0
 618         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 619                 if ! delete_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 620                         rc=$((rc + 1))
 621                 fi
 622         done
 623         [[ $rc != 0 ]] && error "nodemap_del_range failed with $rc" && return 4
 624
 625         rc=0
 626         delete_nodemaps
 627         rc=$?
 628         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 629
 630         return 0
 631 }
 632 run_test 9 "nodemap range add"
 633
 634 test_10a() {
 635         local rc
 636
 637         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 638         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 639                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 640                 return
 641
 642         rc=0
 643         create_nodemaps
 644         rc=$?
 645         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 646
 647         rc=0
 648         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 649                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 650                         rc=$((rc + 1))
 651                 fi
 652         done
 653         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 654
 655         rc=0
 656         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 657                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 658                         rc=$((rc + 1))
 659                 fi
 660         done
 661         [[ $rc == 0 ]] && error "nodemap_add_range duplicate add with $rc" &&
 662                 return 2
 663
 664
 665         rc=0
 666         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 667                 if ! delete_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 668                         rc=$((rc + 1))
 669                 fi
 670         done
 671         [[ $rc != 0 ]] && error "nodemap_del_range failed with $rc" && return 4
 672
 673         delete_nodemaps
 674         rc=$?
 675         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 5
 676
 677         return 0
 678 }
 679 run_test 10a "nodemap reject duplicate ranges"
 680
 681 test_10b() {
 682         [ $(lustre_version_code mgs) -lt $(version_code 2.10.53) ] &&
 683                 skip "Need MGS >= 2.10.53" && return
 684
 685         local nm1="nodemap1"
 686         local nm2="nodemap2"
 687         local nids="192.168.19.[0-255]@o2ib20"
 688
 689         do_facet mgs $LCTL nodemap_del $nm1 2>/dev/null
 690         do_facet mgs $LCTL nodemap_del $nm2 2>/dev/null
 691
 692         do_facet mgs $LCTL nodemap_add $nm1 || error "Add $nm1 failed"
 693         do_facet mgs $LCTL nodemap_add $nm2 || error "Add $nm2 failed"
 694         do_facet mgs $LCTL nodemap_add_range --name $nm1 --range $nids ||
 695                 error "Add range $nids to $nm1 failed"
 696         [ -n "$(do_facet mgs $LCTL get_param nodemap.$nm1.* |
 697                 grep start_nid)" ] || error "No range was found"
 698         do_facet mgs $LCTL nodemap_del_range --name $nm2 --range $nids &&
 699                 error "Deleting range $nids from $nm2 should fail"
 700         [ -n "$(do_facet mgs $LCTL get_param nodemap.$nm1.* |
 701                 grep start_nid)" ] || error "Range $nids should be there"
 702
 703         do_facet mgs $LCTL nodemap_del $nm1 || error "Delete $nm1 failed"
 704         do_facet mgs $LCTL nodemap_del $nm2 || error "Delete $nm2 failed"
 705         return 0
 706 }
 707 run_test 10b "delete range from the correct nodemap"
 708
 709 test_11() {
 710         local rc
 711
 712         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 713         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 714                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 715                 return
 716
 717         rc=0
 718         create_nodemaps
 719         rc=$?
 720         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 721
 722         rc=0
 723         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 724                 if ! modify_flags ${HOSTNAME_CHECKSUM}_${i}; then
 725                         rc=$((rc + 1))
 726                 fi
 727         done
 728         [[ $rc != 0 ]] && error "nodemap_modify with $rc" && return 2
 729
 730         rc=0
 731         delete_nodemaps
 732         rc=$?
 733         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 3
 734
 735         return 0
 736 }
 737 run_test 11 "nodemap modify"
 738
 739 test_12() {
 740         local rc
 741
 742         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 743         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 744                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 745                 return
 746
 747         rc=0
 748         create_nodemaps
 749         rc=$?
 750         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 751
 752         rc=0
 753         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 754                 if ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 0; then
 755                         rc=$((rc + 1))
 756                 fi
 757         done
 758         [[ $rc != 0 ]] && error "nodemap squash_uid with $rc" && return 2
 759
 760         rc=0
 761         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 762                 if ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 1; then
 763                         rc=$((rc + 1))
 764                 fi
 765         done
 766         [[ $rc != 0 ]] && error "nodemap squash_gid with $rc" && return 3
 767
 768         rc=0
 769         delete_nodemaps
 770         rc=$?
 771         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 772
 773         return 0
 774 }
 775 run_test 12 "nodemap set squash ids"
 776
 777 test_13() {
 778         local rc
 779
 780         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 781         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 782                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 783                 return
 784
 785         rc=0
 786         create_nodemaps
 787         rc=$?
 788         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 789
 790         rc=0
 791         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 792                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 793                         rc=$((rc + 1))
 794                 fi
 795         done
 796         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 797
 798         rc=0
 799         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 800                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 801                         for k in $NODEMAP_IPADDR_LIST; do
 802                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
 803                                        ${HOSTNAME_CHECKSUM}_${i}; then
 804                                         rc=$((rc + 1))
 805                                 fi
 806                         done
 807                 done
 808         done
 809         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
 810
 811         rc=0
 812         delete_nodemaps
 813         rc=$?
 814         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 815
 816         return 0
 817 }
 818 run_test 13 "test nids"
 819
 820 test_14() {
 821         local rc
 822
 823         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 824         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 825                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 826                 return
 827
 828         rc=0
 829         create_nodemaps
 830         rc=$?
 831         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 832
 833         rc=0
 834         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 835                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 836                         for k in $NODEMAP_IPADDR_LIST; do
 837                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
 838                                         default; then
 839                                         rc=$((rc + 1))
 840                                 fi
 841                         done
 842                 done
 843         done
 844         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
 845
 846         rc=0
 847         delete_nodemaps
 848         rc=$?
 849         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 850
 851         return 0
 852 }
 853 run_test 14 "test default nodemap nid lookup"
 854
 855 test_15() {
 856         local rc
 857
 858         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 859         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 860                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 861                 return
 862
 863         rc=0
 864         create_nodemaps
 865         rc=$?
 866         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 867
 868         rc=0
 869         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 870                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 871                         rc=$((rc + 1))
 872                 fi
 873         done
 874         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 875
 876         rc=0
 877         add_idmaps
 878         rc=$?
 879         [[ $rc != 0 ]] && error "nodemap_add_idmap failed with $rc" && return 3
 880
 881         rc=0
 882         test_idmap
 883         rc=$?
 884         [[ $rc != 0 ]] && error "nodemap_test_id failed with $rc" && return 4
 885
 886         rc=0
 887         delete_idmaps
 888         rc=$?
 889         [[ $rc != 0 ]] && error "nodemap_del_idmap failed with $rc" && return 5
 890
 891         rc=0
 892         delete_nodemaps
 893         rc=$?
 894         [[ $rc != 0 ]] && error "nodemap_delete failed with $rc" && return 6
 895
 896         return 0
 897 }
 898 run_test 15 "test id mapping"
 899
 900 wait_nm_sync() {
 901         local nodemap_name=$1
 902         local key=$2
 903         local value=$3
 904         local proc_param="${nodemap_name}.${key}"
 905         [ "$nodemap_name" == "active" ] && proc_param="active"
 906
 907         local is_active=$(do_facet mgs $LCTL get_param -n nodemap.active)
 908         (( is_active == 0 )) && [ "$proc_param" != "active" ] && return
 909
 910         local max_retries=20
 911         local is_sync
 912         local out1=""
 913         local out2
 914         local mgs_ip=$(host_nids_address $mgs_HOST $NETTYPE | cut -d' ' -f1)
 915         local i
 916
 917         if [ -z "$value" ]; then
 918                 out1=$(do_facet mgs $LCTL get_param nodemap.${proc_param})
 919                 echo "On MGS ${mgs_ip}, ${proc_param} = $out1"
 920         else
 921                 out1=$value;
 922         fi
 923
 924         # wait up to 10 seconds for other servers to sync with mgs
 925         for i in $(seq 1 10); do
 926                 for node in $(all_server_nodes); do
 927                     local node_ip=$(host_nids_address $node $NETTYPE |
 928                                     cut -d' ' -f1)
 929
 930                     is_sync=true
 931                     if [ -z "$value" ]; then
 932                         [ $node_ip == $mgs_ip ] && continue
 933                     fi
 934
 935                     out2=$(do_node $node_ip $LCTL get_param \
 936                                    nodemap.$proc_param 2>/dev/null)
 937                     echo "On $node ${node_ip}, ${proc_param} = $out2"
 938                     [ "$out1" != "$out2" ] && is_sync=false && break
 939                 done
 940                 $is_sync && break
 941                 sleep 1
 942         done
 943         if ! $is_sync; then
 944                 echo MGS
 945                 echo $out1
 946                 echo OTHER - IP: $node_ip
 947                 echo $out2
 948                 error "mgs and $nodemap_name ${key} mismatch, $i attempts"
 949         fi
 950         echo "waited $((i - 1)) seconds for sync"
 951 }
 952
 953 create_fops_nodemaps() {
 954         local i=0
 955         local client
 956         for client in $clients; do
 957                 local client_ip=$(host_nids_address $client $NETTYPE)
 958                 local client_nid=$(h2nettype $client_ip)
 959                 do_facet mgs $LCTL nodemap_add c${i} || return 1
 960                 do_facet mgs $LCTL nodemap_add_range    \
 961                         --name c${i} --range $client_nid || return 1
 962                 for map in ${FOPS_IDMAPS[i]}; do
 963                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
 964                                 --idtype uid --idmap ${map} || return 1
 965                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
 966                                 --idtype gid --idmap ${map} || return 1
 967                 done
 968
 969                 wait_nm_sync c$i idmap
 970
 971                 i=$((i + 1))
 972         done
 973         return 0
 974 }
 975
 976 delete_fops_nodemaps() {
 977         local i=0
 978         local client
 979         for client in $clients; do
 980                 do_facet mgs $LCTL nodemap_del c${i} || return 1
 981                 i=$((i + 1))
 982         done
 983         return 0
 984 }
 985
 986 fops_mds_index=0
 987 nm_test_mkdir() {
 988         if [ $MDSCOUNT -le 1 ]; then
 989                 do_node ${clients_arr[0]} mkdir -p $DIR/$tdir
 990         else
 991                 # round-robin MDTs to test DNE nodemap support
 992                 [ ! -d $DIR ] && do_node ${clients_arr[0]} mkdir -p $DIR
 993                 do_node ${clients_arr[0]} $LFS setdirstripe -c 1 -i \
 994                         $((fops_mds_index % MDSCOUNT)) $DIR/$tdir
 995                 ((fops_mds_index++))
 996         fi
 997 }
 998
 999 # acl test directory needs to be initialized on a privileged client
1000 fops_test_setup() {
1001         local admin=$(do_facet mgs $LCTL get_param -n nodemap.c0.admin_nodemap)
1002         local trust=$(do_facet mgs $LCTL get_param -n \
1003                 nodemap.c0.trusted_nodemap)
1004
1005         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1006         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1007
1008         wait_nm_sync c0 admin_nodemap
1009         wait_nm_sync c0 trusted_nodemap
1010
1011         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1012         nm_test_mkdir
1013         do_node ${clients_arr[0]} chown $user $DIR/$tdir
1014
1015         do_facet mgs $LCTL nodemap_modify --name c0 \
1016                 --property admin --value $admin
1017         do_facet mgs $LCTL nodemap_modify --name c0 \
1018                 --property trusted --value $trust
1019
1020         # flush MDT locks to make sure they are reacquired before test
1021         do_node ${clients_arr[0]} $LCTL set_param \
1022                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1023
1024         wait_nm_sync c0 admin_nodemap
1025         wait_nm_sync c0 trusted_nodemap
1026 }
1027
1028 # fileset test directory needs to be initialized on a privileged client
1029 fileset_test_setup() {
1030         local nm=$1
1031         local admin=$(do_facet mgs $LCTL get_param -n \
1032                 nodemap.${nm}.admin_nodemap)
1033         local trust=$(do_facet mgs $LCTL get_param -n \
1034                 nodemap.${nm}.trusted_nodemap)
1035
1036         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1037         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1038                 --value 1
1039
1040         wait_nm_sync $nm admin_nodemap
1041         wait_nm_sync $nm trusted_nodemap
1042
1043         # create directory and populate it for subdir mount
1044         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir ||
1045                 error "unable to create dir $MOUNT/$subdir"
1046         do_node ${clients_arr[0]} touch $MOUNT/$subdir/this_is_$subdir ||
1047                 error "unable to create file $MOUNT/$subdir/this_is_$subdir"
1048         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir/$subsubdir ||
1049                 error "unable to create dir $MOUNT/$subdir/$subsubdir"
1050         do_node ${clients_arr[0]} touch \
1051                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir ||
1052                 error "unable to create file \
1053                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir"
1054
1055         do_facet mgs $LCTL nodemap_modify --name $nm \
1056                 --property admin --value $admin
1057         do_facet mgs $LCTL nodemap_modify --name $nm \
1058                 --property trusted --value $trust
1059
1060         # flush MDT locks to make sure they are reacquired before test
1061         do_node ${clients_arr[0]} $LCTL set_param \
1062                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1063
1064         wait_nm_sync $nm admin_nodemap
1065         wait_nm_sync $nm trusted_nodemap
1066 }
1067
1068 # fileset test directory needs to be initialized on a privileged client
1069 fileset_test_cleanup() {
1070         local nm=$1
1071         local admin=$(do_facet mgs $LCTL get_param -n \
1072                 nodemap.${nm}.admin_nodemap)
1073         local trust=$(do_facet mgs $LCTL get_param -n \
1074                 nodemap.${nm}.trusted_nodemap)
1075
1076         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1077         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1078                 --value 1
1079
1080         wait_nm_sync $nm admin_nodemap
1081         wait_nm_sync $nm trusted_nodemap
1082
1083         # cleanup directory created for subdir mount
1084         do_node ${clients_arr[0]} rm -rf $MOUNT/$subdir ||
1085                 error "unable to remove dir $MOUNT/$subdir"
1086
1087         do_facet mgs $LCTL nodemap_modify --name $nm \
1088                 --property admin --value $admin
1089         do_facet mgs $LCTL nodemap_modify --name $nm \
1090                 --property trusted --value $trust
1091
1092         # flush MDT locks to make sure they are reacquired before test
1093         do_node ${clients_arr[0]} $LCTL set_param \
1094                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1095
1096         wait_nm_sync $nm admin_nodemap
1097         wait_nm_sync $nm trusted_nodemap
1098 }
1099
1100 do_create_delete() {
1101         local run_u=$1
1102         local key=$2
1103         local testfile=$DIR/$tdir/$tfile
1104         local rc=0
1105         local c=0 d=0
1106         local qused_new
1107         if $run_u touch $testfile >& /dev/null; then
1108                 c=1
1109                 $run_u rm $testfile && d=1
1110         fi >& /dev/null
1111
1112         local res="$c $d"
1113         local expected=$(get_cr_del_expected $key)
1114         [ "$res" != "$expected" ] &&
1115                 error "test $key, wanted $expected, got $res" && rc=$((rc + 1))
1116         return $rc
1117 }
1118
1119 nodemap_check_quota() {
1120         local run_u="$1"
1121         $run_u lfs quota -q $DIR | awk '{ print $2; exit; }'
1122 }
1123
1124 do_fops_quota_test() {
1125         local run_u=$1
1126         # fuzz quota used to account for possible indirect blocks, etc
1127         local quota_fuzz=$(fs_log_size)
1128         local qused_orig=$(nodemap_check_quota "$run_u")
1129         local qused_high=$((qused_orig + quota_fuzz))
1130         local qused_low=$((qused_orig - quota_fuzz))
1131         local testfile=$DIR/$tdir/$tfile
1132         $run_u dd if=/dev/zero of=$testfile oflag=sync bs=1M count=1 \
1133                 >& /dev/null || error "unable to write quota test file"
1134         sync; sync_all_data || true
1135
1136         local qused_new=$(nodemap_check_quota "$run_u")
1137         [ $((qused_new)) -lt $((qused_low + 1024)) -o \
1138           $((qused_new)) -gt $((qused_high + 1024)) ] &&
1139                 error "$qused_new != $qused_orig + 1M after write, " \
1140                       "fuzz is $quota_fuzz"
1141         $run_u rm $testfile || error "unable to remove quota test file"
1142         wait_delete_completed_mds
1143
1144         qused_new=$(nodemap_check_quota "$run_u")
1145         [ $((qused_new)) -lt $((qused_low)) \
1146                 -o $((qused_new)) -gt $((qused_high)) ] &&
1147                 error "quota not reclaimed, expect $qused_orig, " \
1148                       "got $qused_new, fuzz $quota_fuzz"
1149 }
1150
1151 get_fops_mapped_user() {
1152         local cli_user=$1
1153
1154         for ((i=0; i < ${#FOPS_IDMAPS[@]}; i++)); do
1155                 for map in ${FOPS_IDMAPS[i]}; do
1156                         if [ $(cut -d: -f1 <<< "$map") == $cli_user ]; then
1157                                 cut -d: -f2 <<< "$map"
1158                                 return
1159                         fi
1160                 done
1161         done
1162         echo -1
1163 }
1164
1165 get_cr_del_expected() {
1166         local -a key
1167         IFS=":" read -a key <<< "$1"
1168         local mapmode="${key[0]}"
1169         local mds_user="${key[1]}"
1170         local cluster="${key[2]}"
1171         local cli_user="${key[3]}"
1172         local mode="0${key[4]}"
1173         local SUCCESS="1 1"
1174         local FAILURE="0 0"
1175         local noadmin=0
1176         local mapped=0
1177         local other=0
1178
1179         [[ $mapmode == *mapped* ]] && mapped=1
1180         # only c1 is mapped in these test cases
1181         [[ $mapmode == mapped_trusted* ]] && [ "$cluster" == "c0" ] && mapped=0
1182         [[ $mapmode == *noadmin* ]] && noadmin=1
1183
1184         # o+wx works as long as the user isn't mapped
1185         if [ $((mode & 3)) -eq 3 ]; then
1186                 other=1
1187         fi
1188
1189         # if client user is root, check if root is squashed
1190         if [ "$cli_user" == "0" ]; then
1191                 # squash root succeed, if other bit is on
1192                 case $noadmin in
1193                         0) echo $SUCCESS;;
1194                         1) [ "$other" == "1" ] && echo $SUCCESS
1195                            [ "$other" == "0" ] && echo $FAILURE;;
1196                 esac
1197                 return
1198         fi
1199         if [ "$mapped" == "0" ]; then
1200                 [ "$other" == "1" ] && echo $SUCCESS
1201                 [ "$other" == "0" ] && echo $FAILURE
1202                 return
1203         fi
1204
1205         # if mapped user is mds user, check for u+wx
1206         mapped_user=$(get_fops_mapped_user $cli_user)
1207         [ "$mapped_user" == "-1" ] &&
1208                 error "unable to find mapping for client user $cli_user"
1209
1210         if [ "$mapped_user" == "$mds_user" -a \
1211              $(((mode & 0300) == 0300)) -eq 1 ]; then
1212                 echo $SUCCESS
1213                 return
1214         fi
1215         if [ "$mapped_user" != "$mds_user" -a "$other" == "1" ]; then
1216                 echo $SUCCESS
1217                 return
1218         fi
1219         echo $FAILURE
1220 }
1221
1222 test_fops_admin_cli_i=""
1223 test_fops_chmod_dir() {
1224         local current_cli_i=$1
1225         local perm_bits=$2
1226         local dir_to_chmod=$3
1227         local new_admin_cli_i=""
1228
1229         # do we need to set up a new admin client?
1230         [ "$current_cli_i" == "0" ] && [ "$test_fops_admin_cli_i" != "1" ] &&
1231                 new_admin_cli_i=1
1232         [ "$current_cli_i" != "0" ] && [ "$test_fops_admin_cli_i" != "0" ] &&
1233                 new_admin_cli_i=0
1234
1235         # if only one client, and non-admin, need to flip admin everytime
1236         if [ "$num_clients" == "1" ]; then
1237                 test_fops_admin_client=$clients
1238                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1239                         nodemap.c0.admin_nodemap)
1240                 if [ "$test_fops_admin_val" != "1" ]; then
1241                         do_facet mgs $LCTL nodemap_modify \
1242                                 --name c0 \
1243                                 --property admin \
1244                                 --value 1
1245                         wait_nm_sync c0 admin_nodemap
1246                 fi
1247         elif [ "$new_admin_cli_i" != "" ]; then
1248                 # restore admin val to old admin client
1249                 if [ "$test_fops_admin_cli_i" != "" ] &&
1250                                 [ "$test_fops_admin_val" != "1" ]; then
1251                         do_facet mgs $LCTL nodemap_modify \
1252                                 --name c${test_fops_admin_cli_i} \
1253                                 --property admin \
1254                                 --value $test_fops_admin_val
1255                         wait_nm_sync c${test_fops_admin_cli_i} admin_nodemap
1256                 fi
1257
1258                 test_fops_admin_cli_i=$new_admin_cli_i
1259                 test_fops_admin_client=${clients_arr[$new_admin_cli_i]}
1260                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1261                         nodemap.c${new_admin_cli_i}.admin_nodemap)
1262
1263                 if [ "$test_fops_admin_val" != "1" ]; then
1264                         do_facet mgs $LCTL nodemap_modify \
1265                                 --name c${new_admin_cli_i} \
1266                                 --property admin \
1267                                 --value 1
1268                         wait_nm_sync c${new_admin_cli_i} admin_nodemap
1269                 fi
1270         fi
1271
1272         do_node $test_fops_admin_client chmod $perm_bits $DIR/$tdir || return 1
1273
1274         # remove admin for single client if originally non-admin
1275         if [ "$num_clients" == "1" ] && [ "$test_fops_admin_val" != "1" ]; then
1276                 do_facet mgs $LCTL nodemap_modify --name c0 --property admin \
1277                         --value 0
1278                 wait_nm_sync c0 admin_nodemap
1279         fi
1280
1281         return 0
1282 }
1283
1284 test_fops() {
1285         local mapmode="$1"
1286         local single_client="$2"
1287         local client_user_list=([0]="0 $((IDBASE+3)) $((IDBASE+4))"
1288                                 [1]="0 $((IDBASE+5)) $((IDBASE+6))")
1289         local mds_i
1290         local rc=0
1291         local perm_bit_list="0 3 $((0300)) $((0303))"
1292         # SLOW tests 000-007, 010-070, 100-700 (octal modes)
1293         [ "$SLOW" == "yes" ] &&
1294                 perm_bit_list="0 $(seq 1 7) $(seq 8 8 63) $(seq 64 64 511) \
1295                                $((0303))"
1296
1297         # step through mds users. -1 means root
1298         for mds_i in -1 0 1 2; do
1299                 local user=$((mds_i + IDBASE))
1300                 local client
1301                 local x
1302
1303                 [ "$mds_i" == "-1" ] && user=0
1304
1305                 echo mkdir -p $DIR/$tdir
1306                 fops_test_setup
1307                 local cli_i=0
1308                 for client in $clients; do
1309                         local u
1310                         for u in ${client_user_list[$cli_i]}; do
1311                                 local run_u="do_node $client \
1312                                              $RUNAS_CMD -u$u -g$u -G$u"
1313                                 for perm_bits in $perm_bit_list; do
1314                                         local mode=$(printf %03o $perm_bits)
1315                                         local key
1316                                         key="$mapmode:$user:c$cli_i:$u:$mode"
1317                                         test_fops_chmod_dir $cli_i $mode \
1318                                                 $DIR/$tdir ||
1319                                                         error cannot chmod $key
1320                                         do_create_delete "$run_u" "$key"
1321                                 done
1322
1323                                 # check quota
1324                                 test_fops_chmod_dir $cli_i 777 $DIR/$tdir ||
1325                                         error cannot chmod $key
1326                                 do_fops_quota_test "$run_u"
1327                         done
1328
1329                         cli_i=$((cli_i + 1))
1330                         [ "$single_client" == "1" ] && break
1331                 done
1332                 rm -rf $DIR/$tdir
1333         done
1334         return $rc
1335 }
1336
1337 nodemap_version_check () {
1338         remote_mgs_nodsh && skip "remote MGS with nodsh" && return 1
1339         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
1340                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
1341                 return 1
1342         return 0
1343 }
1344
1345 nodemap_test_setup() {
1346         local rc
1347         local active_nodemap=1
1348
1349         [ "$1" == "0" ] && active_nodemap=0
1350
1351         do_nodes $(comma_list $(all_mdts_nodes)) \
1352                 $LCTL set_param mdt.*.identity_upcall=NONE
1353
1354         rc=0
1355         create_fops_nodemaps
1356         rc=$?
1357         [[ $rc != 0 ]] && error "adding fops nodemaps failed $rc"
1358
1359         do_facet mgs $LCTL nodemap_activate $active_nodemap
1360         wait_nm_sync active
1361
1362         do_facet mgs $LCTL nodemap_modify --name default \
1363                 --property admin --value 1
1364         do_facet mgs $LCTL nodemap_modify --name default \
1365                 --property trusted --value 1
1366         wait_nm_sync default trusted_nodemap
1367 }
1368
1369 nodemap_test_cleanup() {
1370         trap 0
1371         delete_fops_nodemaps
1372         rc=$?
1373         [[ $rc != 0 ]] && error "removing fops nodemaps failed $rc"
1374
1375         do_facet mgs $LCTL nodemap_modify --name default \
1376                  --property admin --value 0
1377         do_facet mgs $LCTL nodemap_modify --name default \
1378                  --property trusted --value 0
1379         wait_nm_sync default trusted_nodemap
1380
1381         do_facet mgs $LCTL nodemap_activate 0
1382         wait_nm_sync active 0
1383
1384         export SK_UNIQUE_NM=false
1385         return 0
1386 }
1387
1388 nodemap_clients_admin_trusted() {
1389         local admin=$1
1390         local tr=$2
1391         local i=0
1392         for client in $clients; do
1393                 do_facet mgs $LCTL nodemap_modify --name c0 \
1394                         --property admin --value $admin
1395                 do_facet mgs $LCTL nodemap_modify --name c0 \
1396                         --property trusted --value $tr
1397                 i=$((i + 1))
1398         done
1399         wait_nm_sync c$((i - 1)) admin_nodemap
1400         wait_nm_sync c$((i - 1)) trusted_nodemap
1401 }
1402
1403 test_16() {
1404         nodemap_version_check || return 0
1405         nodemap_test_setup 0
1406
1407         trap nodemap_test_cleanup EXIT
1408         test_fops all_off
1409         nodemap_test_cleanup
1410 }
1411 run_test 16 "test nodemap all_off fileops"
1412
1413 test_17() {
1414         nodemap_version_check || return 0
1415         nodemap_test_setup
1416
1417         trap nodemap_test_cleanup EXIT
1418         nodemap_clients_admin_trusted 0 1
1419         test_fops trusted_noadmin 1
1420         nodemap_test_cleanup
1421 }
1422 run_test 17 "test nodemap trusted_noadmin fileops"
1423
1424 test_18() {
1425         nodemap_version_check || return 0
1426         nodemap_test_setup
1427
1428         trap nodemap_test_cleanup EXIT
1429         nodemap_clients_admin_trusted 0 0
1430         test_fops mapped_noadmin 1
1431         nodemap_test_cleanup
1432 }
1433 run_test 18 "test nodemap mapped_noadmin fileops"
1434
1435 test_19() {
1436         nodemap_version_check || return 0
1437         nodemap_test_setup
1438
1439         trap nodemap_test_cleanup EXIT
1440         nodemap_clients_admin_trusted 1 1
1441         test_fops trusted_admin 1
1442         nodemap_test_cleanup
1443 }
1444 run_test 19 "test nodemap trusted_admin fileops"
1445
1446 test_20() {
1447         nodemap_version_check || return 0
1448         nodemap_test_setup
1449
1450         trap nodemap_test_cleanup EXIT
1451         nodemap_clients_admin_trusted 1 0
1452         test_fops mapped_admin 1
1453         nodemap_test_cleanup
1454 }
1455 run_test 20 "test nodemap mapped_admin fileops"
1456
1457 test_21() {
1458         nodemap_version_check || return 0
1459         nodemap_test_setup
1460
1461         trap nodemap_test_cleanup EXIT
1462         local x=1
1463         local i=0
1464         for client in $clients; do
1465                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1466                         --property admin --value 0
1467                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1468                         --property trusted --value $x
1469                 x=0
1470                 i=$((i + 1))
1471         done
1472         wait_nm_sync c$((i - 1)) trusted_nodemap
1473
1474         test_fops mapped_trusted_noadmin
1475         nodemap_test_cleanup
1476 }
1477 run_test 21 "test nodemap mapped_trusted_noadmin fileops"
1478
1479 test_22() {
1480         nodemap_version_check || return 0
1481         nodemap_test_setup
1482
1483         trap nodemap_test_cleanup EXIT
1484         local x=1
1485         local i=0
1486         for client in $clients; do
1487                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1488                         --property admin --value 1
1489                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1490                         --property trusted --value $x
1491                 x=0
1492                 i=$((i + 1))
1493         done
1494         wait_nm_sync c$((i - 1)) trusted_nodemap
1495
1496         test_fops mapped_trusted_admin
1497         nodemap_test_cleanup
1498 }
1499 run_test 22 "test nodemap mapped_trusted_admin fileops"
1500
1501 # acl test directory needs to be initialized on a privileged client
1502 nodemap_acl_test_setup() {
1503         local admin=$(do_facet mgs $LCTL get_param -n \
1504                       nodemap.c0.admin_nodemap)
1505         local trust=$(do_facet mgs $LCTL get_param -n \
1506                       nodemap.c0.trusted_nodemap)
1507
1508         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1509         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1510
1511         wait_nm_sync c0 admin_nodemap
1512         wait_nm_sync c0 trusted_nodemap
1513
1514         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1515         nm_test_mkdir
1516         do_node ${clients_arr[0]} chmod a+rwx $DIR/$tdir ||
1517                 error unable to chmod a+rwx test dir $DIR/$tdir
1518
1519         do_facet mgs $LCTL nodemap_modify --name c0 \
1520                 --property admin --value $admin
1521         do_facet mgs $LCTL nodemap_modify --name c0 \
1522                 --property trusted --value $trust
1523
1524         wait_nm_sync c0 trusted_nodemap
1525 }
1526
1527 # returns 0 if the number of ACLs does not change on the second (mapped) client
1528 # after being set on the first client
1529 nodemap_acl_test() {
1530         local user="$1"
1531         local set_client="$2"
1532         local get_client="$3"
1533         local check_setfacl="$4"
1534         local setfacl_error=0
1535         local testfile=$DIR/$tdir/$tfile
1536         local RUNAS_USER="$RUNAS_CMD -u $user"
1537         local acl_count=0
1538         local acl_count_post=0
1539
1540         nodemap_acl_test_setup
1541         sleep 5
1542
1543         do_node $set_client $RUNAS_USER touch $testfile
1544
1545         # ACL masks aren't filtered by nodemap code, so we ignore them
1546         acl_count=$(do_node $get_client getfacl $testfile | grep -v mask |
1547                 wc -l)
1548         do_node $set_client $RUNAS_USER setfacl -m $user:rwx $testfile ||
1549                 setfacl_error=1
1550
1551         # if check setfacl is set to 1, then it's supposed to error
1552         if [ "$check_setfacl" == "1" ]; then
1553                 [ "$setfacl_error" != "1" ] && return 1
1554                 return 0
1555         fi
1556         [ "$setfacl_error" == "1" ] && echo "WARNING: unable to setfacl"
1557
1558         acl_count_post=$(do_node $get_client getfacl $testfile | grep -v mask |
1559                 wc -l)
1560         [ $acl_count -eq $acl_count_post ] && return 0
1561         return 1
1562 }
1563
1564 test_23a() {
1565         nodemap_version_check || return 0
1566         nodemap_test_setup
1567
1568         trap nodemap_test_cleanup EXIT
1569         # 1 trusted cluster, 1 mapped cluster
1570         local unmapped_fs=$((IDBASE+0))
1571         local unmapped_c1=$((IDBASE+5))
1572         local mapped_fs=$((IDBASE+2))
1573         local mapped_c0=$((IDBASE+4))
1574         local mapped_c1=$((IDBASE+6))
1575
1576         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1577         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1578
1579         do_facet mgs $LCTL nodemap_modify --name c1 --property admin --value 0
1580         do_facet mgs $LCTL nodemap_modify --name c1 --property trusted --value 0
1581
1582         wait_nm_sync c1 trusted_nodemap
1583
1584         # setfacl on trusted cluster to unmapped user, verify it's not seen
1585         nodemap_acl_test $unmapped_fs ${clients_arr[0]} ${clients_arr[1]} ||
1586                 error "acl count (1)"
1587
1588         # setfacl on trusted cluster to mapped user, verify it's seen
1589         nodemap_acl_test $mapped_fs ${clients_arr[0]} ${clients_arr[1]} &&
1590                 error "acl count (2)"
1591
1592         # setfacl on mapped cluster to mapped user, verify it's seen
1593         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1594                 error "acl count (3)"
1595
1596         # setfacl on mapped cluster to unmapped user, verify error
1597         nodemap_acl_test $unmapped_fs ${clients_arr[1]} ${clients_arr[0]} 1 ||
1598                 error "acl count (4)"
1599
1600         # 2 mapped clusters
1601         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 0
1602         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 0
1603
1604         wait_nm_sync c0 trusted_nodemap
1605
1606         # setfacl to mapped user on c1, also mapped to c0, verify it's seen
1607         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1608                 error "acl count (5)"
1609
1610         # setfacl to mapped user on c1, not mapped to c0, verify not seen
1611         nodemap_acl_test $unmapped_c1 ${clients_arr[1]} ${clients_arr[0]} ||
1612                 error "acl count (6)"
1613
1614         nodemap_test_cleanup
1615 }
1616 run_test 23a "test mapped regular ACLs"
1617
1618 test_23b() { #LU-9929
1619         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
1620         [ $(lustre_version_code mgs) -lt $(version_code 2.10.53) ] &&
1621                 skip "Need MGS >= 2.10.53" && return
1622
1623         nodemap_test_setup
1624         trap nodemap_test_cleanup EXIT
1625
1626         local testdir=$DIR/$tdir
1627         local fs_id=$((IDBASE+10))
1628         local unmapped_id
1629         local mapped_id
1630         local fs_user
1631
1632         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1633         wait_nm_sync c0 admin_nodemap
1634
1635         # Add idmap $ID0:$fs_id (500:60010)
1636         do_facet mgs $LCTL nodemap_add_idmap --name c0 --idtype gid \
1637                 --idmap $ID0:$fs_id ||
1638                 error "add idmap $ID0:$fs_id to nodemap c0 failed"
1639
1640         # set/getfacl default acl on client0 (unmapped gid=500)
1641         rm -rf $testdir
1642         mkdir -p $testdir
1643         # Here, USER0=$(getent passwd | grep :$ID0:$ID0: | cut -d: -f1)
1644         setfacl -R -d -m group:$USER0:rwx $testdir ||
1645                 error "setfacl $testdir on ${clients_arr[0]} failed"
1646         unmapped_id=$(getfacl $testdir | grep -E "default:group:.*:rwx" |
1647                         awk -F: '{print $3}')
1648         [ "$unmapped_id" = "$USER0" ] ||
1649                 error "gid=$ID0 was not unmapped correctly on ${clients_arr[0]}"
1650
1651         # getfacl default acl on MGS (mapped gid=60010)
1652         zconf_mount $mgs_HOST $MOUNT
1653         do_rpc_nodes $mgs_HOST is_mounted $MOUNT ||
1654                 error "mount lustre on MGS failed"
1655         mapped_id=$(do_node $mgs_HOST getfacl $testdir |
1656                         grep -E "default:group:.*:rwx" | awk -F: '{print $3}')
1657         fs_user=$(do_facet mgs getent passwd |
1658                         grep :$fs_id:$fs_id: | cut -d: -f1)
1659         [ $mapped_id -eq $fs_id -o "$mapped_id" = "$fs_user" ] ||
1660                 error "Should return gid=$fs_id or $fs_user on MGS"
1661
1662         rm -rf $testdir
1663         do_facet mgs umount $MOUNT
1664         nodemap_test_cleanup
1665 }
1666 run_test 23b "test mapped default ACLs"
1667
1668 test_24() {
1669         nodemap_test_setup
1670
1671         trap nodemap_test_cleanup EXIT
1672         do_nodes $(comma_list $(all_server_nodes)) $LCTL get_param -R nodemap ||
1673                 error "proc readable file read failed"
1674
1675         nodemap_test_cleanup
1676 }
1677 run_test 24 "check nodemap proc files for LBUGs and Oopses"
1678
1679 test_25() {
1680         local tmpfile=$(mktemp)
1681         local tmpfile2=$(mktemp)
1682         local tmpfile3=$(mktemp)
1683         local tmpfile4=$(mktemp)
1684         local subdir=c0dir
1685         local client
1686
1687         nodemap_version_check || return 0
1688
1689         # stop clients for this test
1690         zconf_umount_clients $CLIENTS $MOUNT ||
1691             error "unable to umount clients $CLIENTS"
1692
1693         export SK_UNIQUE_NM=true
1694         nodemap_test_setup
1695
1696         # enable trusted/admin for setquota call in cleanup_and_setup_lustre()
1697         i=0
1698         for client in $clients; do
1699                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1700                         --property admin --value 1
1701                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1702                         --property trusted --value 1
1703                 ((i++))
1704         done
1705         wait_nm_sync c$((i - 1)) trusted_nodemap
1706
1707         trap nodemap_test_cleanup EXIT
1708
1709         # create a new, empty nodemap, and add fileset info to it
1710         do_facet mgs $LCTL nodemap_add test25 ||
1711                 error "unable to create nodemap $testname"
1712         do_facet mgs $LCTL set_param -P nodemap.$testname.fileset=/$subdir ||
1713                 error "unable to add fileset info to nodemap test25"
1714
1715         wait_nm_sync test25 id
1716
1717         do_facet mgs $LCTL nodemap_info > $tmpfile
1718         do_facet mds $LCTL nodemap_info > $tmpfile2
1719
1720         if ! $SHARED_KEY; then
1721                 # will conflict with SK's nodemaps
1722                 cleanup_and_setup_lustre
1723         fi
1724         # stop clients for this test
1725         zconf_umount_clients $CLIENTS $MOUNT ||
1726             error "unable to umount clients $CLIENTS"
1727
1728         do_facet mgs $LCTL nodemap_info > $tmpfile3
1729         diff -q $tmpfile3 $tmpfile >& /dev/null ||
1730                 error "nodemap_info diff on MGS after remount"
1731
1732         do_facet mds $LCTL nodemap_info > $tmpfile4
1733         diff -q $tmpfile4 $tmpfile2 >& /dev/null ||
1734                 error "nodemap_info diff on MDS after remount"
1735
1736         # cleanup nodemap
1737         do_facet mgs $LCTL nodemap_del test25 ||
1738             error "cannot delete nodemap test25 from config"
1739         nodemap_test_cleanup
1740         # restart clients previously stopped
1741         zconf_mount_clients $CLIENTS $MOUNT ||
1742             error "unable to mount clients $CLIENTS"
1743
1744         rm -f $tmpfile $tmpfile2
1745         export SK_UNIQUE_NM=false
1746 }
1747 run_test 25 "test save and reload nodemap config"
1748
1749 test_26() {
1750         nodemap_version_check || return 0
1751
1752         local large_i=32000
1753
1754         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_add"
1755         wait_nm_sync c$large_i admin_nodemap
1756
1757         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_del"
1758         wait_nm_sync c$large_i admin_nodemap
1759 }
1760 run_test 26 "test transferring very large nodemap"
1761
1762 nodemap_exercise_fileset() {
1763         local nm="$1"
1764         local fileset_on_mgs=""
1765         local loop=0
1766
1767         # setup
1768         if [ "$nm" == "default" ]; then
1769                 do_facet mgs $LCTL nodemap_activate 1
1770                 wait_nm_sync active
1771         else
1772                 nodemap_test_setup
1773         fi
1774         if $SHARED_KEY; then
1775                 export SK_UNIQUE_NM=true
1776         else
1777                 # will conflict with SK's nodemaps
1778                 trap "fileset_test_cleanup $nm" EXIT
1779         fi
1780         fileset_test_setup "$nm"
1781
1782         # add fileset info to $nm nodemap
1783         do_facet mgs $LCTL set_param nodemap.${nm}.fileset=/$subdir ||
1784                 error "unable to add fileset info to $nm nodemap on MGS"
1785         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=/$subdir ||
1786                error "unable to add fileset info to $nm nodemap for servers"
1787         wait_nm_sync $nm fileset "nodemap.${nm}.fileset=/$subdir"
1788
1789         # re-mount client
1790         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1791                 error "unable to umount client ${clients_arr[0]}"
1792         # set some generic fileset to trigger SSK code
1793         export FILESET=/
1794         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1795                 error "unable to remount client ${clients_arr[0]}"
1796         unset FILESET
1797
1798         # test mount point content
1799         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subdir ||
1800                 error "fileset not taken into account"
1801
1802         # re-mount client with sub-subdir
1803         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1804                 error "unable to umount client ${clients_arr[0]}"
1805         export FILESET=/$subsubdir
1806         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1807                 error "unable to remount client ${clients_arr[0]}"
1808         unset FILESET
1809
1810         # test mount point content
1811         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subsubdir ||
1812                 error "subdir of fileset not taken into account"
1813
1814         # remove fileset info from nodemap
1815         do_facet mgs $LCTL nodemap_set_fileset --name $nm --fileset \'\' ||
1816                 error "unable to delete fileset info on $nm nodemap"
1817         wait_update_facet mgs "$LCTL get_param nodemap.${nm}.fileset" \
1818                           "nodemap.${nm}.fileset=" ||
1819                 error "fileset info still not cleared on $nm nodemap"
1820         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=\'\' ||
1821                 error "unable to reset fileset info on $nm nodemap"
1822         wait_nm_sync $nm fileset "nodemap.${nm}.fileset="
1823
1824         # re-mount client
1825         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1826                 error "unable to umount client ${clients_arr[0]}"
1827         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1828                 error "unable to remount client ${clients_arr[0]}"
1829
1830         # test mount point content
1831         if ! $(do_node ${clients_arr[0]} test -d $MOUNT/$subdir); then
1832                 ls $MOUNT
1833                 error "fileset not cleared on $nm nodemap"
1834         fi
1835
1836         # back to non-nodemap setup
1837         if $SHARED_KEY; then
1838                 export SK_UNIQUE_NM=false
1839                 zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1840                         error "unable to umount client ${clients_arr[0]}"
1841         fi
1842         fileset_test_cleanup "$nm"
1843         if [ "$nm" == "default" ]; then
1844                 do_facet mgs $LCTL nodemap_activate 0
1845                 wait_nm_sync active 0
1846                 trap 0
1847                 export SK_UNIQUE_NM=false
1848         else
1849                 nodemap_test_cleanup
1850         fi
1851         if $SHARED_KEY; then
1852                 zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1853                         error "unable to remount client ${clients_arr[0]}"
1854         fi
1855 }
1856
1857 test_27() {
1858         for nm in "default" "c0"; do
1859                 local subdir="subdir_${nm}"
1860                 local subsubdir="subsubdir_${nm}"
1861
1862                 echo "Exercising fileset for nodemap $nm"
1863                 nodemap_exercise_fileset "$nm"
1864         done
1865 }
1866 run_test 27 "test fileset in various nodemaps"
1867
1868 test_28() {
1869         if ! $SHARED_KEY; then
1870                 skip "need shared key feature for this test" && return
1871         fi
1872         mkdir -p $DIR/$tdir || error "mkdir failed"
1873         touch $DIR/$tdir/$tdir.out || error "touch failed"
1874         if [ ! -f $DIR/$tdir/$tdir.out ]; then
1875                 error "read before rotation failed"
1876         fi
1877         # store top key identity to ensure rotation has occurred
1878         SK_IDENTITY_OLD=$(lctl get_param *.*.*srpc* | grep "expire" |
1879                 head -1 | awk '{print $15}' | cut -c1-8)
1880         do_facet $SINGLEMDS lfs flushctx ||
1881                  error "could not run flushctx on $SINGLEMDS"
1882         sleep 5
1883         lfs flushctx || error "could not run flushctx on client"
1884         sleep 5
1885         # verify new key is in place
1886         SK_IDENTITY_NEW=$(lctl get_param *.*.*srpc* | grep "expire" |
1887                 head -1 | awk '{print $15}' | cut -c1-8)
1888         if [ $SK_IDENTITY_OLD == $SK_IDENTITY_NEW ]; then
1889                 error "key did not rotate correctly"
1890         fi
1891         if [ ! -f $DIR/$tdir/$tdir.out ]; then
1892                 error "read after rotation failed"
1893         fi
1894 }
1895 run_test 28 "check shared key rotation method"
1896
1897 test_29() {
1898         if ! $SHARED_KEY; then
1899                 skip "need shared key feature for this test" && return
1900         fi
1901         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
1902                 skip "test only valid if integrity is active"
1903         fi
1904         rm -r $DIR/$tdir
1905         mkdir $DIR/$tdir || error "mkdir"
1906         touch $DIR/$tdir/$tfile || error "touch"
1907         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1908                 error "unable to umount clients"
1909         keyctl show | awk '/lustre/ { print $1 }' |
1910                 xargs -IX keyctl unlink X
1911         OLD_SK_PATH=$SK_PATH
1912         export SK_PATH=/dev/null
1913         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
1914                 export SK_PATH=$OLD_SK_PATH
1915                 if [ -e $DIR/$tdir/$tfile ]; then
1916                         error "able to mount and read without key"
1917                 else
1918                         error "able to mount without key"
1919                 fi
1920         else
1921                 export SK_PATH=$OLD_SK_PATH
1922                 keyctl show | awk '/lustre/ { print $1 }' |
1923                         xargs -IX keyctl unlink X
1924         fi
1925 }
1926 run_test 29 "check for missing shared key"
1927
1928 test_30() {
1929         if ! $SHARED_KEY; then
1930                 skip "need shared key feature for this test" && return
1931         fi
1932         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
1933                 skip "test only valid if integrity is active"
1934         fi
1935         mkdir -p $DIR/$tdir || error "mkdir failed"
1936         touch $DIR/$tdir/$tdir.out || error "touch failed"
1937         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1938                 error "unable to umount clients"
1939         # unload keys from ring
1940         keyctl show | awk '/lustre/ { print $1 }' |
1941                 xargs -IX keyctl unlink X
1942         # invalidate the key with bogus filesystem name
1943         lgss_sk -w $SK_PATH/$FSNAME-bogus.key -f $FSNAME.bogus \
1944                 -t client -d /dev/urandom || error "lgss_sk failed (1)"
1945         do_facet $SINGLEMDS lfs flushctx || error "could not run flushctx"
1946         OLD_SK_PATH=$SK_PATH
1947         export SK_PATH=$SK_PATH/$FSNAME-bogus.key
1948         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
1949                 SK_PATH=$OLD_SK_PATH
1950                 if [ -a $DIR/$tdir/$tdir.out ]; then
1951                         error "mount and read file with invalid key"
1952                 else
1953                         error "mount with invalid key"
1954                 fi
1955         fi
1956         SK_PATH=$OLD_SK_PATH
1957         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1958                 error "unable to umount clients"
1959 }
1960 run_test 30 "check for invalid shared key"
1961
1962 log "cleanup: ======================================================"
1963
1964 sec_unsetup() {
1965         ## nodemap deactivated
1966         do_facet mgs $LCTL nodemap_activate 0
1967
1968         for num in $(seq $MDSCOUNT); do
1969                 if [ "${identity_old[$num]}" = 1 ]; then
1970                         switch_identity $num false || identity_old[$num]=$?
1971                 fi
1972         done
1973
1974         $RUNAS_CMD -u $ID0 ls $DIR
1975         $RUNAS_CMD -u $ID1 ls $DIR
1976 }
1977 sec_unsetup
1978
1979 sec_cleanup
1980
1981 complete $SECONDS
1982 exit_status