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 # UPDATE THE COMMENT ABOVE WITH BUG NUMBERS WHEN CHANGING ALWAYS_EXCEPT!
  13
  14 SRCDIR=$(dirname $0)
  15 export PATH=$PWD/$SRCDIR:$SRCDIR:$PWD/$SRCDIR/../utils:$PATH:/sbin
  16 export NAME=${NAME:-local}
  17
  18 LUSTRE=${LUSTRE:-$(dirname $0)/..}
  19 . $LUSTRE/tests/test-framework.sh
  20 init_test_env $@
  21 . ${CONFIG:=$LUSTRE/tests/cfg/$NAME.sh}
  22 get_lustre_env
  23 init_logging
  24
  25 NODEMAP_TESTS=$(seq 7 26)
  26
  27 if ! check_versions; then
  28         echo "It is NOT necessary to test nodemap under interoperation mode"
  29         EXCEPT="$EXCEPT $NODEMAP_TESTS"
  30 fi
  31
  32 [ "$SLOW" = "no" ] && EXCEPT_SLOW="26"
  33
  34 [ "$ALWAYS_EXCEPT$EXCEPT$EXCEPT_SLOW" ] &&
  35         echo "Skipping tests: $ALWAYS_EXCEPT $EXCEPT $EXCEPT_SLOW"
  36
  37 RUNAS_CMD=${RUNAS_CMD:-runas}
  38
  39 WTL=${WTL:-"$LUSTRE/tests/write_time_limit"}
  40
  41 CONFDIR=/etc/lustre
  42 PERM_CONF=$CONFDIR/perm.conf
  43 FAIL_ON_ERROR=false
  44 HOSTNAME_CHECKSUM=$(hostname | sum | awk '{ print $1 }')
  45 SUBNET_CHECKSUM=$(expr $HOSTNAME_CHECKSUM % 250 + 1)
  46
  47 require_dsh_mds || exit 0
  48 require_dsh_ost || exit 0
  49
  50 clients=${CLIENTS//,/ }
  51 num_clients=$(get_node_count ${clients})
  52 clients_arr=($clients)
  53
  54 ID0=${ID0:-500}
  55 ID1=${ID1:-501}
  56 USER0=$(getent passwd | grep :$ID0:$ID0: | cut -d: -f1)
  57 USER1=$(getent passwd | grep :$ID1:$ID1: | cut -d: -f1)
  58
  59 NODEMAP_COUNT=16
  60 NODEMAP_RANGE_COUNT=3
  61 NODEMAP_IPADDR_LIST="1 10 64 128 200 250"
  62 NODEMAP_ID_COUNT=10
  63 NODEMAP_MAX_ID=$((ID0 + NODEMAP_ID_COUNT))
  64
  65 [ -z "$USER0" ] &&
  66         skip "need to add user0 ($ID0:$ID0)" && exit 0
  67
  68 [ -z "$USER1" ] &&
  69         skip "need to add user1 ($ID1:$ID1)" && exit 0
  70
  71 IDBASE=${IDBASE:-60000}
  72
  73 # changes to mappings must be reflected in test 23
  74 FOPS_IDMAPS=(
  75         [0]="$((IDBASE+3)):$((IDBASE+0)) $((IDBASE+4)):$((IDBASE+2))"
  76         [1]="$((IDBASE+5)):$((IDBASE+1)) $((IDBASE+6)):$((IDBASE+2))"
  77         )
  78
  79 check_and_setup_lustre
  80
  81 assert_DIR
  82
  83 # for GSS_SUP
  84 GSS_REF=$(lsmod | grep ^ptlrpc_gss | awk '{print $3}')
  85 if [ ! -z "$GSS_REF" -a "$GSS_REF" != "0" ]; then
  86         GSS_SUP=1
  87         echo "with GSS support"
  88 else
  89         GSS_SUP=0
  90         echo "without GSS support"
  91 fi
  92
  93 MDT=$(do_facet $SINGLEMDS lctl get_param -N "mdt.\*MDT0000" |
  94         cut -d. -f2 || true)
  95 [ -z "$MDT" ] && error "fail to get MDT device" && exit 1
  96 do_facet $SINGLEMDS "mkdir -p $CONFDIR"
  97 IDENTITY_FLUSH=mdt.$MDT.identity_flush
  98 IDENTITY_UPCALL=mdt.$MDT.identity_upcall
  99
 100 SAVE_PWD=$PWD
 101
 102 build_test_filter
 103
 104 sec_login() {
 105         local user=$1
 106         local group=$2
 107
 108         $GSS_KRB5 || return
 109         if ! $RUNAS_CMD -u $user krb5_login.sh; then
 110                 error "$user login kerberos failed."
 111                 exit 1
 112         fi
 113
 114         if ! $RUNAS_CMD -u $user -g $group ls $DIR > /dev/null 2>&1; then
 115                 $RUNAS_CMD -u $user lfs flushctx -k
 116                 $RUNAS_CMD -u $user krb5_login.sh
 117                 if ! $RUNAS_CMD -u$user -g$group ls $DIR > /dev/null 2>&1; then
 118                         error "init $user $group failed."
 119                         exit 2
 120                 fi
 121         fi
 122 }
 123
 124 declare -a identity_old
 125
 126 sec_setup() {
 127         for num in $(seq $MDSCOUNT); do
 128                 switch_identity $num true || identity_old[$num]=$?
 129         done
 130
 131         if ! $RUNAS_CMD -u $ID0 ls $DIR > /dev/null 2>&1; then
 132                 sec_login $USER0 $USER0
 133         fi
 134
 135         if ! $RUNAS_CMD -u $ID1 ls $DIR > /dev/null 2>&1; then
 136                 sec_login $USER1 $USER1
 137         fi
 138 }
 139 sec_setup
 140
 141 # run as different user
 142 test_0() {
 143         umask 0022
 144
 145         chmod 0755 $DIR || error "chmod (1)"
 146         rm -rf $DIR/$tdir || error "rm (1)"
 147         mkdir -p $DIR/$tdir || error "mkdir (1)"
 148         chown $USER0 $DIR/$tdir || error "chown (2)"
 149         $RUNAS_CMD -u $ID0 ls $DIR || error "ls (1)"
 150         rm -f $DIR/f0 || error "rm (2)"
 151         $RUNAS_CMD -u $ID0 touch $DIR/f0 && error "touch (1)"
 152         $RUNAS_CMD -u $ID0 touch $DIR/$tdir/f1 || error "touch (2)"
 153         $RUNAS_CMD -u $ID1 touch $DIR/$tdir/f2 && error "touch (3)"
 154         touch $DIR/$tdir/f3 || error "touch (4)"
 155         chown root $DIR/$tdir || error "chown (3)"
 156         chgrp $USER0 $DIR/$tdir || error "chgrp (1)"
 157         chmod 0775 $DIR/$tdir || error "chmod (2)"
 158         $RUNAS_CMD -u $ID0 touch $DIR/$tdir/f4 || error "touch (5)"
 159         $RUNAS_CMD -u $ID1 touch $DIR/$tdir/f5 && error "touch (6)"
 160         touch $DIR/$tdir/f6 || error "touch (7)"
 161         rm -rf $DIR/$tdir || error "rm (3)"
 162 }
 163 run_test 0 "uid permission ============================="
 164
 165 # setuid/gid
 166 test_1() {
 167         [ $GSS_SUP = 0 ] && skip "without GSS support." && return
 168
 169         rm -rf $DIR/$tdir
 170         mkdir -p $DIR/$tdir
 171
 172         chown $USER0 $DIR/$tdir || error "chown (1)"
 173         $RUNAS_CMD -u $ID1 -v $ID0 touch $DIR/$tdir/f0 && error "touch (2)"
 174         echo "enable uid $ID1 setuid"
 175         do_facet $SINGLEMDS "echo '* $ID1 setuid' >> $PERM_CONF"
 176         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 177         $RUNAS_CMD -u $ID1 -v $ID0 touch $DIR/$tdir/f1 || error "touch (3)"
 178
 179         chown root $DIR/$tdir || error "chown (4)"
 180         chgrp $USER0 $DIR/$tdir || error "chgrp (5)"
 181         chmod 0770 $DIR/$tdir || error "chmod (6)"
 182         $RUNAS_CMD -u $ID1 -g $ID1 touch $DIR/$tdir/f2 && error "touch (7)"
 183         $RUNAS_CMD -u$ID1 -g$ID1 -j$ID0 touch $DIR/$tdir/f3 && error "touch (8)"
 184         echo "enable uid $ID1 setuid,setgid"
 185         do_facet $SINGLEMDS "echo '* $ID1 setuid,setgid' > $PERM_CONF"
 186         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 187         $RUNAS_CMD -u $ID1 -g $ID1 -j $ID0 touch $DIR/$tdir/f4 ||
 188                 error "touch (9)"
 189         $RUNAS_CMD -u $ID1 -v $ID0 -g $ID1 -j $ID0 touch $DIR/$tdir/f5 ||
 190                 error "touch (10)"
 191
 192         rm -rf $DIR/$tdir
 193
 194         do_facet $SINGLEMDS "rm -f $PERM_CONF"
 195         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 196 }
 197 run_test 1 "setuid/gid ============================="
 198
 199 # bug 3285 - supplementary group should always succeed.
 200 # NB: the supplementary groups are set for local client only,
 201 # as for remote client, the groups of the specified uid on MDT
 202 # will be obtained by upcall /sbin/l_getidentity and used.
 203 test_4() {
 204         local server_version=$(lustre_version_code $SINGLEMDS)
 205
 206         [[ $server_version -ge $(version_code 2.6.93) ]] ||
 207         [[ $server_version -ge $(version_code 2.5.35) &&
 208            $server_version -lt $(version_code 2.5.50) ]] ||
 209                 { skip "Need MDS version at least 2.6.93 or 2.5.35"; return; }
 210
 211         rm -rf $DIR/$tdir
 212         mkdir -p $DIR/$tdir
 213         chmod 0771 $DIR/$tdir
 214         chgrp $ID0 $DIR/$tdir
 215         $RUNAS_CMD -u $ID0 ls $DIR/$tdir || error "setgroups (1)"
 216         do_facet $SINGLEMDS "echo '* $ID1 setgrp' > $PERM_CONF"
 217         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 218         $RUNAS_CMD -u $ID1 -G1,2,$ID0 ls $DIR/$tdir ||
 219                 error "setgroups (2)"
 220         $RUNAS_CMD -u $ID1 -G1,2 ls $DIR/$tdir && error "setgroups (3)"
 221         rm -rf $DIR/$tdir
 222
 223         do_facet $SINGLEMDS "rm -f $PERM_CONF"
 224         do_facet $SINGLEMDS "lctl set_param -n $IDENTITY_FLUSH=-1"
 225 }
 226 run_test 4 "set supplementary group ==============="
 227
 228 create_nodemaps() {
 229         local i
 230         local out
 231         local rc
 232
 233         squash_id default 99 0
 234         wait_nm_sync default squash_uid '' inactive
 235         squash_id default 99 1
 236         wait_nm_sync default squash_gid '' inactive
 237         for (( i = 0; i < NODEMAP_COUNT; i++ )); do
 238                 local csum=${HOSTNAME_CHECKSUM}_${i}
 239
 240                 do_facet mgs $LCTL nodemap_add $csum
 241                 rc=$?
 242                 if [ $rc -ne 0 ]; then
 243                         echo "nodemap_add $csum failed with $rc"
 244                         return $rc
 245                 fi
 246
 247                 out=$(do_facet mgs $LCTL get_param nodemap.$csum.id)
 248                 ## This needs to return zero if the following statement is 1
 249                 [[ $(echo $out | grep -c $csum) == 0 ]] && return 1
 250         done
 251         for (( i = 0; i < NODEMAP_COUNT; i++ )); do
 252                 local csum=${HOSTNAME_CHECKSUM}_${i}
 253
 254                 wait_nm_sync $csum id '' inactive
 255         done
 256         return 0
 257 }
 258
 259 delete_nodemaps() {
 260         local i
 261         local out
 262
 263         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 264                 local csum=${HOSTNAME_CHECKSUM}_${i}
 265
 266                 if ! do_facet mgs $LCTL nodemap_del $csum; then
 267                         error "nodemap_del $csum failed with $?"
 268                         return 3
 269                 fi
 270
 271                 out=$(do_facet mgs $LCTL get_param nodemap.$csum.id 2>/dev/null)
 272                 [[ $(echo $out | grep -c $csum) != 0 ]] && return 1
 273         done
 274         for (( i = 0; i < NODEMAP_COUNT; i++ )); do
 275                 local csum=${HOSTNAME_CHECKSUM}_${i}
 276
 277                 wait_nm_sync $csum id '' inactive
 278         done
 279         return 0
 280 }
 281
 282 add_range() {
 283         local j
 284         local cmd="$LCTL nodemap_add_range"
 285         local range
 286         local rc=0
 287
 288         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 289                 range="$SUBNET_CHECKSUM.${2}.${j}.[1-253]@tcp"
 290                 if ! do_facet mgs $cmd --name $1 --range $range; then
 291                         rc=$((rc + 1))
 292                 fi
 293         done
 294         return $rc
 295 }
 296
 297 delete_range() {
 298         local j
 299         local cmd="$LCTL nodemap_del_range"
 300         local range
 301         local rc=0
 302
 303         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 304                 range="$SUBNET_CHECKSUM.${2}.${j}.[1-253]@tcp"
 305                 if ! do_facet mgs $cmd --name $1 --range $range; then
 306                         rc=$((rc + 1))
 307                 fi
 308         done
 309
 310         return $rc
 311 }
 312
 313 add_idmaps() {
 314         local i
 315         local cmd="$LCTL nodemap_add_idmap"
 316         local rc=0
 317
 318         echo "Start to add idmaps ..."
 319         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 320                 local j
 321
 322                 for ((j = $ID0; j < NODEMAP_MAX_ID; j++)); do
 323                         local csum=${HOSTNAME_CHECKSUM}_${i}
 324                         local client_id=$j
 325                         local fs_id=$((j + 1))
 326
 327                         if ! do_facet mgs $cmd --name $csum --idtype uid \
 328                              --idmap $client_id:$fs_id; then
 329                                 rc=$((rc + 1))
 330                         fi
 331                         if ! do_facet mgs $cmd --name $csum --idtype gid \
 332                              --idmap $client_id:$fs_id; then
 333                                 rc=$((rc + 1))
 334                         fi
 335                 done
 336         done
 337
 338         return $rc
 339 }
 340
 341 update_idmaps() { #LU-10040
 342         [ $(lustre_version_code mgs) -lt $(version_code 2.10.55) ] &&
 343                 skip "Need MGS >= 2.10.55" &&
 344                 return
 345         local csum=${HOSTNAME_CHECKSUM}_0
 346         local old_id_client=$ID0
 347         local old_id_fs=$((ID0 + 1))
 348         local new_id=$((ID0 + 100))
 349         local tmp_id
 350         local cmd
 351         local run
 352         local idtype
 353         local rc=0
 354
 355         echo "Start to update idmaps ..."
 356
 357         #Inserting an existed idmap should return error
 358         cmd="$LCTL nodemap_add_idmap --name $csum --idtype uid"
 359         if do_facet mgs \
 360                 $cmd --idmap $old_id_client:$old_id_fs 2>/dev/null; then
 361                 error "insert idmap {$old_id_client:$old_id_fs} " \
 362                         "should return error"
 363                 rc=$((rc + 1))
 364                 return rc
 365         fi
 366
 367         #Update id_fs and check it
 368         if ! do_facet mgs $cmd --idmap $old_id_client:$new_id; then
 369                 error "$cmd --idmap $old_id_client:$new_id failed"
 370                 rc=$((rc + 1))
 371                 return $rc
 372         fi
 373         tmp_id=$(do_facet mgs $LCTL get_param -n nodemap.$csum.idmap |
 374                 awk '{ print $7 }' | sed -n '2p')
 375         [ $tmp_id != $new_id ] && { error "new id_fs $tmp_id != $new_id"; \
 376                 rc=$((rc + 1)); return $rc; }
 377
 378         #Update id_client and check it
 379         if ! do_facet mgs $cmd --idmap $new_id:$new_id; then
 380                 error "$cmd --idmap $new_id:$new_id failed"
 381                 rc=$((rc + 1))
 382                 return $rc
 383         fi
 384         tmp_id=$(do_facet mgs $LCTL get_param -n nodemap.$csum.idmap |
 385                 awk '{ print $5 }' | sed -n "$((NODEMAP_ID_COUNT + 1)) p")
 386         tmp_id=$(echo ${tmp_id%,*}) #e.g. "501,"->"501"
 387         [ $tmp_id != $new_id ] && { error "new id_client $tmp_id != $new_id"; \
 388                 rc=$((rc + 1)); return $rc; }
 389
 390         #Delete above updated idmap
 391         cmd="$LCTL nodemap_del_idmap --name $csum --idtype uid"
 392         if ! do_facet mgs $cmd --idmap $new_id:$new_id; then
 393                 error "$cmd --idmap $new_id:$new_id failed"
 394                 rc=$((rc + 1))
 395                 return $rc
 396         fi
 397
 398         #restore the idmaps to make delete_idmaps work well
 399         cmd="$LCTL nodemap_add_idmap --name $csum --idtype uid"
 400         if ! do_facet mgs $cmd --idmap $old_id_client:$old_id_fs; then
 401                 error "$cmd --idmap $old_id_client:$old_id_fs failed"
 402                 rc=$((rc + 1))
 403                 return $rc
 404         fi
 405
 406         return $rc
 407 }
 408
 409 delete_idmaps() {
 410         local i
 411         local cmd="$LCTL nodemap_del_idmap"
 412         local rc=0
 413
 414         echo "Start to delete idmaps ..."
 415         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 416                 local j
 417
 418                 for ((j = $ID0; j < NODEMAP_MAX_ID; j++)); do
 419                         local csum=${HOSTNAME_CHECKSUM}_${i}
 420                         local client_id=$j
 421                         local fs_id=$((j + 1))
 422
 423                         if ! do_facet mgs $cmd --name $csum --idtype uid \
 424                              --idmap $client_id:$fs_id; then
 425                                 rc=$((rc + 1))
 426                         fi
 427                         if ! do_facet mgs $cmd --name $csum --idtype gid \
 428                              --idmap $client_id:$fs_id; then
 429                                 rc=$((rc + 1))
 430                         fi
 431                 done
 432         done
 433
 434         return $rc
 435 }
 436
 437 modify_flags() {
 438         local i
 439         local proc
 440         local option
 441         local cmd="$LCTL nodemap_modify"
 442         local rc=0
 443
 444         proc[0]="admin_nodemap"
 445         proc[1]="trusted_nodemap"
 446         option[0]="admin"
 447         option[1]="trusted"
 448
 449         for ((idx = 0; idx < 2; idx++)); do
 450                 if ! do_facet mgs $cmd --name $1 --property ${option[$idx]} \
 451                      --value 1; then
 452                         rc=$((rc + 1))
 453                 fi
 454
 455                 if ! do_facet mgs $cmd --name $1 --property ${option[$idx]} \
 456                      --value 0; then
 457                         rc=$((rc + 1))
 458                 fi
 459         done
 460
 461         return $rc
 462 }
 463
 464 squash_id() {
 465         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 466                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 467                 return
 468         local cmd
 469
 470         cmd[0]="$LCTL nodemap_modify --property squash_uid"
 471         cmd[1]="$LCTL nodemap_modify --property squash_gid"
 472
 473         if ! do_facet mgs ${cmd[$3]} --name $1 --value $2; then
 474                 return 1
 475         fi
 476 }
 477
 478 wait_nm_sync() {
 479         local nodemap_name=$1
 480         local key=$2
 481         local value=$3
 482         local opt=$4
 483         local proc_param
 484         local is_active=$(do_facet mgs $LCTL get_param -n nodemap.active)
 485         local max_retries=20
 486         local is_sync
 487         local out1=""
 488         local out2
 489         local mgs_ip=$(host_nids_address $mgs_HOST $NETTYPE | cut -d' ' -f1)
 490         local i
 491
 492         if [ "$nodemap_name" == "active" ]; then
 493                 proc_param="active"
 494         elif [ -z "$key" ]; then
 495                 proc_param=${nodemap_name}
 496         else
 497                 proc_param="${nodemap_name}.${key}"
 498         fi
 499         if [ "$opt" == "inactive" ]; then
 500                 # check nm sync even if nodemap is not activated
 501                 is_active=1
 502                 opt=""
 503         fi
 504         (( is_active == 0 )) && [ "$proc_param" != "active" ] && return
 505
 506         if [ -z "$value" ]; then
 507                 out1=$(do_facet mgs $LCTL get_param $opt \
 508                         nodemap.${proc_param} 2>/dev/null)
 509                 echo "On MGS ${mgs_ip}, ${proc_param} = $out1"
 510         else
 511                 out1=$value;
 512         fi
 513
 514         # wait up to 10 seconds for other servers to sync with mgs
 515         for i in $(seq 1 10); do
 516                 for node in $(all_server_nodes); do
 517                     local node_ip=$(host_nids_address $node $NETTYPE |
 518                                     cut -d' ' -f1)
 519
 520                     is_sync=true
 521                     if [ -z "$value" ]; then
 522                         [ $node_ip == $mgs_ip ] && continue
 523                     fi
 524
 525                     out2=$(do_node $node_ip $LCTL get_param $opt \
 526                                    nodemap.$proc_param 2>/dev/null)
 527                     echo "On $node ${node_ip}, ${proc_param} = $out2"
 528                     [ "$out1" != "$out2" ] && is_sync=false && break
 529                 done
 530                 $is_sync && break
 531                 sleep 1
 532         done
 533         if ! $is_sync; then
 534                 echo MGS
 535                 echo $out1
 536                 echo OTHER - IP: $node_ip
 537                 echo $out2
 538                 error "mgs and $nodemap_name ${key} mismatch, $i attempts"
 539         fi
 540         echo "waited $((i - 1)) seconds for sync"
 541 }
 542
 543 # ensure that the squash defaults are the expected defaults
 544 squash_id default 99 0
 545 wait_nm_sync default squash_uid '' inactive
 546 squash_id default 99 1
 547 wait_nm_sync default squash_gid '' inactive
 548
 549 test_nid() {
 550         local cmd
 551
 552         cmd="$LCTL nodemap_test_nid"
 553
 554         nid=$(do_facet mgs $cmd $1)
 555
 556         if [ $nid == $2 ]; then
 557                 return 0
 558         fi
 559
 560         return 1
 561 }
 562
 563 cleanup_active() {
 564         # restore activation state
 565         do_facet mgs $LCTL nodemap_activate 0
 566         wait_nm_sync active
 567 }
 568
 569 test_idmap() {
 570         local i
 571         local cmd="$LCTL nodemap_test_id"
 572         local rc=0
 573
 574         echo "Start to test idmaps ..."
 575         ## nodemap deactivated
 576         if ! do_facet mgs $LCTL nodemap_activate 0; then
 577                 return 1
 578         fi
 579         for ((id = $ID0; id < NODEMAP_MAX_ID; id++)); do
 580                 local j
 581
 582                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 583                         local nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 584                         local fs_id=$(do_facet mgs $cmd --nid $nid      \
 585                                       --idtype uid --id $id)
 586                         if [ $fs_id != $id ]; then
 587                                 echo "expected $id, got $fs_id"
 588                                 rc=$((rc + 1))
 589                         fi
 590                 done
 591         done
 592
 593         ## nodemap activated
 594         if ! do_facet mgs $LCTL nodemap_activate 1; then
 595                 return 2
 596         fi
 597
 598         for ((id = $ID0; id < NODEMAP_MAX_ID; id++)); do
 599                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 600                         nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 601                         fs_id=$(do_facet mgs $cmd --nid $nid    \
 602                                 --idtype uid --id $id)
 603                         expected_id=$((id + 1))
 604                         if [ $fs_id != $expected_id ]; then
 605                                 echo "expected $expected_id, got $fs_id"
 606                                 rc=$((rc + 1))
 607                         fi
 608                 done
 609         done
 610
 611         ## trust client ids
 612         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 613                 local csum=${HOSTNAME_CHECKSUM}_${i}
 614
 615                 if ! do_facet mgs $LCTL nodemap_modify --name $csum \
 616                      --property trusted --value 1; then
 617                         error "nodemap_modify $csum failed with $?"
 618                         return 3
 619                 fi
 620         done
 621
 622         for ((id = $ID0; id < NODEMAP_MAX_ID; id++)); do
 623                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 624                         nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 625                         fs_id=$(do_facet mgs $cmd --nid $nid    \
 626                                 --idtype uid --id $id)
 627                         if [ $fs_id != $id ]; then
 628                                 echo "expected $id, got $fs_id"
 629                                 rc=$((rc + 1))
 630                         fi
 631                 done
 632         done
 633
 634         ## ensure allow_root_access is enabled
 635         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 636                 local csum=${HOSTNAME_CHECKSUM}_${i}
 637
 638                 if ! do_facet mgs $LCTL nodemap_modify --name $csum     \
 639                      --property admin --value 1; then
 640                         error "nodemap_modify $csum failed with $?"
 641                         return 3
 642                 fi
 643         done
 644
 645         ## check that root allowed
 646         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 647                 nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 648                 fs_id=$(do_facet mgs $cmd --nid $nid --idtype uid --id 0)
 649                 if [ $fs_id != 0 ]; then
 650                         echo "root allowed expected 0, got $fs_id"
 651                         rc=$((rc + 1))
 652                 fi
 653         done
 654
 655         ## ensure allow_root_access is disabled
 656         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 657                 local csum=${HOSTNAME_CHECKSUM}_${i}
 658
 659                 if ! do_facet mgs $LCTL nodemap_modify --name $csum     \
 660                                 --property admin --value 0; then
 661                         error "nodemap_modify ${HOSTNAME_CHECKSUM}_${i} "
 662                                 "failed with $rc"
 663                         return 3
 664                 fi
 665         done
 666
 667         ## check that root is mapped to 99
 668         for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 669                 nid="$SUBNET_CHECKSUM.0.${j}.100@tcp"
 670                 fs_id=$(do_facet mgs $cmd --nid $nid --idtype uid --id 0)
 671                 if [ $fs_id != 99 ]; then
 672                         error "root squash expected 99, got $fs_id"
 673                         rc=$((rc + 1))
 674                 fi
 675         done
 676
 677         ## reset client trust to 0
 678         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 679                 if ! do_facet mgs $LCTL nodemap_modify          \
 680                         --name ${HOSTNAME_CHECKSUM}_${i}        \
 681                         --property trusted --value 0; then
 682                         error "nodemap_modify ${HOSTNAME_CHECKSUM}_${i} "
 683                                 "failed with $rc"
 684                         return 3
 685                 fi
 686         done
 687
 688         return $rc
 689 }
 690
 691 test_7() {
 692         local rc
 693
 694         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 695         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 696                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 697                 return
 698
 699         create_nodemaps
 700         rc=$?
 701         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 702
 703         delete_nodemaps
 704         rc=$?
 705         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 2
 706
 707         return 0
 708 }
 709 run_test 7 "nodemap create and delete"
 710
 711 test_8() {
 712         local rc
 713
 714         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 715         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 716                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 717                 return
 718
 719         # Set up nodemaps
 720
 721         create_nodemaps
 722         rc=$?
 723         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 724
 725         # Try duplicates
 726
 727         create_nodemaps
 728         rc=$?
 729         [[ $rc == 0 ]] && error "duplicate nodemap_add allowed with $rc" &&
 730         return 2
 731
 732         # Clean up
 733         delete_nodemaps
 734         rc=$?
 735         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 3
 736
 737         return 0
 738 }
 739 run_test 8 "nodemap reject duplicates"
 740
 741 test_9() {
 742         local i
 743         local rc
 744
 745         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 746         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 747                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 748                 return
 749
 750         rc=0
 751         create_nodemaps
 752         rc=$?
 753         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 754
 755         rc=0
 756         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 757                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 758                         rc=$((rc + 1))
 759                 fi
 760         done
 761         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 762
 763         rc=0
 764         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 765                 if ! delete_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 766                         rc=$((rc + 1))
 767                 fi
 768         done
 769         [[ $rc != 0 ]] && error "nodemap_del_range failed with $rc" && return 4
 770
 771         rc=0
 772         delete_nodemaps
 773         rc=$?
 774         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 775
 776         return 0
 777 }
 778 run_test 9 "nodemap range add"
 779
 780 test_10a() {
 781         local rc
 782
 783         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 784         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 785                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 786                 return
 787
 788         rc=0
 789         create_nodemaps
 790         rc=$?
 791         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 792
 793         rc=0
 794         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 795                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 796                         rc=$((rc + 1))
 797                 fi
 798         done
 799         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 800
 801         rc=0
 802         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 803                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 804                         rc=$((rc + 1))
 805                 fi
 806         done
 807         [[ $rc == 0 ]] && error "nodemap_add_range duplicate add with $rc" &&
 808                 return 2
 809
 810
 811         rc=0
 812         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 813                 if ! delete_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 814                         rc=$((rc + 1))
 815                 fi
 816         done
 817         [[ $rc != 0 ]] && error "nodemap_del_range failed with $rc" && return 4
 818
 819         delete_nodemaps
 820         rc=$?
 821         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 5
 822
 823         return 0
 824 }
 825 run_test 10a "nodemap reject duplicate ranges"
 826
 827 test_10b() {
 828         [ $(lustre_version_code mgs) -lt $(version_code 2.10.53) ] &&
 829                 skip "Need MGS >= 2.10.53" && return
 830
 831         local nm1="nodemap1"
 832         local nm2="nodemap2"
 833         local nids="192.168.19.[0-255]@o2ib20"
 834
 835         do_facet mgs $LCTL nodemap_del $nm1 2>/dev/null
 836         do_facet mgs $LCTL nodemap_del $nm2 2>/dev/null
 837
 838         do_facet mgs $LCTL nodemap_add $nm1 || error "Add $nm1 failed"
 839         do_facet mgs $LCTL nodemap_add $nm2 || error "Add $nm2 failed"
 840         do_facet mgs $LCTL nodemap_add_range --name $nm1 --range $nids ||
 841                 error "Add range $nids to $nm1 failed"
 842         [ -n "$(do_facet mgs $LCTL get_param nodemap.$nm1.* |
 843                 grep start_nid)" ] || error "No range was found"
 844         do_facet mgs $LCTL nodemap_del_range --name $nm2 --range $nids &&
 845                 error "Deleting range $nids from $nm2 should fail"
 846         [ -n "$(do_facet mgs $LCTL get_param nodemap.$nm1.* |
 847                 grep start_nid)" ] || error "Range $nids should be there"
 848
 849         do_facet mgs $LCTL nodemap_del $nm1 || error "Delete $nm1 failed"
 850         do_facet mgs $LCTL nodemap_del $nm2 || error "Delete $nm2 failed"
 851         return 0
 852 }
 853 run_test 10b "delete range from the correct nodemap"
 854
 855 test_10c() { #LU-8912
 856         [ $(lustre_version_code mgs) -lt $(version_code 2.10.57) ] &&
 857                 skip "Need MGS >= 2.10.57" && return
 858
 859         local nm="nodemap_lu8912"
 860         local nid_range="10.210.[32-47].[0-255]@o2ib3"
 861         local start_nid="10.210.32.0@o2ib3"
 862         local end_nid="10.210.47.255@o2ib3"
 863         local start_nid_found
 864         local end_nid_found
 865
 866         do_facet mgs $LCTL nodemap_del $nm 2>/dev/null
 867         do_facet mgs $LCTL nodemap_add $nm || error "Add $nm failed"
 868         do_facet mgs $LCTL nodemap_add_range --name $nm --range $nid_range ||
 869                 error "Add range $nid_range to $nm failed"
 870
 871         start_nid_found=$(do_facet mgs $LCTL get_param nodemap.$nm.* |
 872                 awk -F '[,: ]' /start_nid/'{ print $9 }')
 873         [ "$start_nid" == "$start_nid_found" ] ||
 874                 error "start_nid: $start_nid_found != $start_nid"
 875         end_nid_found=$(do_facet mgs $LCTL get_param nodemap.$nm.* |
 876                 awk -F '[,: ]' /end_nid/'{ print $13 }')
 877         [ "$end_nid" == "$end_nid_found" ] ||
 878                 error "end_nid: $end_nid_found != $end_nid"
 879
 880         do_facet mgs $LCTL nodemap_del $nm || error "Delete $nm failed"
 881         return 0
 882 }
 883 run_test 10c "verfify contiguous range support"
 884
 885 test_10d() { #LU-8913
 886         [ $(lustre_version_code mgs) -lt $(version_code 2.10.59) ] &&
 887                 skip "Need MGS >= 2.10.59" && return
 888
 889         local nm="nodemap_lu8913"
 890         local nid_range="*@o2ib3"
 891         local start_nid="0.0.0.0@o2ib3"
 892         local end_nid="255.255.255.255@o2ib3"
 893         local start_nid_found
 894         local end_nid_found
 895
 896         do_facet mgs $LCTL nodemap_del $nm 2>/dev/null
 897         do_facet mgs $LCTL nodemap_add $nm || error "Add $nm failed"
 898         do_facet mgs $LCTL nodemap_add_range --name $nm --range $nid_range ||
 899                 error "Add range $nid_range to $nm failed"
 900
 901         start_nid_found=$(do_facet mgs $LCTL get_param nodemap.$nm.* |
 902                 awk -F '[,: ]' /start_nid/'{ print $9 }')
 903         [ "$start_nid" == "$start_nid_found" ] ||
 904                 error "start_nid: $start_nid_found != $start_nid"
 905         end_nid_found=$(do_facet mgs $LCTL get_param nodemap.$nm.* |
 906                 awk -F '[,: ]' /end_nid/'{ print $13 }')
 907         [ "$end_nid" == "$end_nid_found" ] ||
 908                 error "end_nid: $end_nid_found != $end_nid"
 909
 910         do_facet mgs $LCTL nodemap_del $nm || error "Delete $nm failed"
 911         return 0
 912 }
 913 run_test 10d "verfify nodemap range format '*@<net>' support"
 914
 915 test_11() {
 916         local rc
 917
 918         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 919         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 920                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 921                 return
 922
 923         rc=0
 924         create_nodemaps
 925         rc=$?
 926         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 927
 928         rc=0
 929         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 930                 if ! modify_flags ${HOSTNAME_CHECKSUM}_${i}; then
 931                         rc=$((rc + 1))
 932                 fi
 933         done
 934         [[ $rc != 0 ]] && error "nodemap_modify with $rc" && return 2
 935
 936         rc=0
 937         delete_nodemaps
 938         rc=$?
 939         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 3
 940
 941         return 0
 942 }
 943 run_test 11 "nodemap modify"
 944
 945 test_12() {
 946         local rc
 947
 948         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 949         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 950                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 951                 return
 952
 953         rc=0
 954         create_nodemaps
 955         rc=$?
 956         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 957
 958         rc=0
 959         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 960                 if ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 0; then
 961                         rc=$((rc + 1))
 962                 fi
 963         done
 964         [[ $rc != 0 ]] && error "nodemap squash_uid with $rc" && return 2
 965
 966         rc=0
 967         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 968                 if ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 1; then
 969                         rc=$((rc + 1))
 970                 fi
 971         done
 972         [[ $rc != 0 ]] && error "nodemap squash_gid with $rc" && return 3
 973
 974         rc=0
 975         delete_nodemaps
 976         rc=$?
 977         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 978
 979         return 0
 980 }
 981 run_test 12 "nodemap set squash ids"
 982
 983 test_13() {
 984         local rc
 985
 986         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 987         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 988                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 989                 return
 990
 991         rc=0
 992         create_nodemaps
 993         rc=$?
 994         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 995
 996         rc=0
 997         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 998                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 999                         rc=$((rc + 1))
1000                 fi
1001         done
1002         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
1003
1004         rc=0
1005         for ((i = 0; i < NODEMAP_COUNT; i++)); do
1006                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
1007                         for k in $NODEMAP_IPADDR_LIST; do
1008                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
1009                                        ${HOSTNAME_CHECKSUM}_${i}; then
1010                                         rc=$((rc + 1))
1011                                 fi
1012                         done
1013                 done
1014         done
1015         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
1016
1017         rc=0
1018         delete_nodemaps
1019         rc=$?
1020         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
1021
1022         return 0
1023 }
1024 run_test 13 "test nids"
1025
1026 test_14() {
1027         local rc
1028
1029         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
1030         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
1031                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
1032                 return
1033
1034         rc=0
1035         create_nodemaps
1036         rc=$?
1037         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
1038
1039         rc=0
1040         for ((i = 0; i < NODEMAP_COUNT; i++)); do
1041                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
1042                         for k in $NODEMAP_IPADDR_LIST; do
1043                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
1044                                         default; then
1045                                         rc=$((rc + 1))
1046                                 fi
1047                         done
1048                 done
1049         done
1050         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
1051
1052         rc=0
1053         delete_nodemaps
1054         rc=$?
1055         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
1056
1057         return 0
1058 }
1059 run_test 14 "test default nodemap nid lookup"
1060
1061 test_15() {
1062         local rc
1063
1064         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
1065         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
1066                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
1067                 return
1068
1069         rc=0
1070         create_nodemaps
1071         rc=$?
1072         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
1073
1074         rc=0
1075         for ((i = 0; i < NODEMAP_COUNT; i++)); do
1076                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
1077                         rc=$((rc + 1))
1078                 fi
1079         done
1080         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
1081
1082         rc=0
1083         add_idmaps
1084         rc=$?
1085         [[ $rc != 0 ]] && error "nodemap_add_idmap failed with $rc" && return 3
1086
1087         activedefault=$(do_facet mgs $LCTL get_param -n nodemap.active)
1088         if [[ "$activedefault" != "1" ]]; then
1089                 stack_trap cleanup_active EXIT
1090         fi
1091
1092         rc=0
1093         test_idmap
1094         rc=$?
1095         [[ $rc != 0 ]] && error "nodemap_test_id failed with $rc" && return 4
1096
1097         rc=0
1098         update_idmaps
1099         rc=$?
1100         [[ $rc != 0 ]] && error "update_idmaps failed with $rc" && return 5
1101
1102         rc=0
1103         delete_idmaps
1104         rc=$?
1105         [[ $rc != 0 ]] && error "nodemap_del_idmap failed with $rc" && return 6
1106
1107         rc=0
1108         delete_nodemaps
1109         rc=$?
1110         [[ $rc != 0 ]] && error "nodemap_delete failed with $rc" && return 7
1111
1112         return 0
1113 }
1114 run_test 15 "test id mapping"
1115
1116 create_fops_nodemaps() {
1117         local i=0
1118         local client
1119         for client in $clients; do
1120                 local client_ip=$(host_nids_address $client $NETTYPE)
1121                 local client_nid=$(h2nettype $client_ip)
1122                 do_facet mgs $LCTL nodemap_add c${i} || return 1
1123                 do_facet mgs $LCTL nodemap_add_range    \
1124                         --name c${i} --range $client_nid || return 1
1125                 for map in ${FOPS_IDMAPS[i]}; do
1126                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
1127                                 --idtype uid --idmap ${map} || return 1
1128                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
1129                                 --idtype gid --idmap ${map} || return 1
1130                 done
1131
1132                 wait_nm_sync c$i idmap
1133
1134                 i=$((i + 1))
1135         done
1136         return 0
1137 }
1138
1139 delete_fops_nodemaps() {
1140         local i=0
1141         local client
1142         for client in $clients; do
1143                 do_facet mgs $LCTL nodemap_del c${i} || return 1
1144                 i=$((i + 1))
1145         done
1146         return 0
1147 }
1148
1149 fops_mds_index=0
1150 nm_test_mkdir() {
1151         if [ $MDSCOUNT -le 1 ]; then
1152                 do_node ${clients_arr[0]} mkdir -p $DIR/$tdir
1153         else
1154                 # round-robin MDTs to test DNE nodemap support
1155                 [ ! -d $DIR ] && do_node ${clients_arr[0]} mkdir -p $DIR
1156                 do_node ${clients_arr[0]} $LFS setdirstripe -c 1 -i \
1157                         $((fops_mds_index % MDSCOUNT)) $DIR/$tdir
1158                 ((fops_mds_index++))
1159         fi
1160 }
1161
1162 # acl test directory needs to be initialized on a privileged client
1163 fops_test_setup() {
1164         local admin=$(do_facet mgs $LCTL get_param -n nodemap.c0.admin_nodemap)
1165         local trust=$(do_facet mgs $LCTL get_param -n \
1166                 nodemap.c0.trusted_nodemap)
1167
1168         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1169         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1170
1171         wait_nm_sync c0 admin_nodemap
1172         wait_nm_sync c0 trusted_nodemap
1173
1174         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1175         nm_test_mkdir
1176         do_node ${clients_arr[0]} chown $user $DIR/$tdir
1177
1178         do_facet mgs $LCTL nodemap_modify --name c0 \
1179                 --property admin --value $admin
1180         do_facet mgs $LCTL nodemap_modify --name c0 \
1181                 --property trusted --value $trust
1182
1183         # flush MDT locks to make sure they are reacquired before test
1184         do_node ${clients_arr[0]} $LCTL set_param \
1185                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1186
1187         wait_nm_sync c0 admin_nodemap
1188         wait_nm_sync c0 trusted_nodemap
1189 }
1190
1191 # fileset test directory needs to be initialized on a privileged client
1192 fileset_test_setup() {
1193         local nm=$1
1194
1195         if [ -n "$FILESET" -a -z "$SKIP_FILESET" ]; then
1196                 cleanup_mount $MOUNT
1197                 FILESET="" zconf_mount_clients $CLIENTS $MOUNT
1198         fi
1199
1200         local admin=$(do_facet mgs $LCTL get_param -n \
1201                 nodemap.${nm}.admin_nodemap)
1202         local trust=$(do_facet mgs $LCTL get_param -n \
1203                 nodemap.${nm}.trusted_nodemap)
1204
1205         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1206         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1207                 --value 1
1208
1209         wait_nm_sync $nm admin_nodemap
1210         wait_nm_sync $nm trusted_nodemap
1211
1212         # create directory and populate it for subdir mount
1213         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir ||
1214                 error "unable to create dir $MOUNT/$subdir"
1215         do_node ${clients_arr[0]} touch $MOUNT/$subdir/this_is_$subdir ||
1216                 error "unable to create file $MOUNT/$subdir/this_is_$subdir"
1217         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir/$subsubdir ||
1218                 error "unable to create dir $MOUNT/$subdir/$subsubdir"
1219         do_node ${clients_arr[0]} touch \
1220                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir ||
1221                 error "unable to create file \
1222                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir"
1223
1224         do_facet mgs $LCTL nodemap_modify --name $nm \
1225                 --property admin --value $admin
1226         do_facet mgs $LCTL nodemap_modify --name $nm \
1227                 --property trusted --value $trust
1228
1229         # flush MDT locks to make sure they are reacquired before test
1230         do_node ${clients_arr[0]} $LCTL set_param \
1231                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1232
1233         wait_nm_sync $nm admin_nodemap
1234         wait_nm_sync $nm trusted_nodemap
1235 }
1236
1237 # fileset test directory needs to be initialized on a privileged client
1238 fileset_test_cleanup() {
1239         local nm=$1
1240         local admin=$(do_facet mgs $LCTL get_param -n \
1241                 nodemap.${nm}.admin_nodemap)
1242         local trust=$(do_facet mgs $LCTL get_param -n \
1243                 nodemap.${nm}.trusted_nodemap)
1244
1245         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1246         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1247                 --value 1
1248
1249         wait_nm_sync $nm admin_nodemap
1250         wait_nm_sync $nm trusted_nodemap
1251
1252         # cleanup directory created for subdir mount
1253         do_node ${clients_arr[0]} rm -rf $MOUNT/$subdir ||
1254                 error "unable to remove dir $MOUNT/$subdir"
1255
1256         do_facet mgs $LCTL nodemap_modify --name $nm \
1257                 --property admin --value $admin
1258         do_facet mgs $LCTL nodemap_modify --name $nm \
1259                 --property trusted --value $trust
1260
1261         # flush MDT locks to make sure they are reacquired before test
1262         do_node ${clients_arr[0]} $LCTL set_param \
1263                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1264
1265         wait_nm_sync $nm admin_nodemap
1266         wait_nm_sync $nm trusted_nodemap
1267         if [ -n "$FILESET" -a -z "$SKIP_FILESET" ]; then
1268                 cleanup_mount $MOUNT
1269                 zconf_mount_clients $CLIENTS $MOUNT
1270         fi
1271 }
1272
1273 do_create_delete() {
1274         local run_u=$1
1275         local key=$2
1276         local testfile=$DIR/$tdir/$tfile
1277         local rc=0
1278         local c=0 d=0
1279         local qused_new
1280         if $run_u touch $testfile >& /dev/null; then
1281                 c=1
1282                 $run_u rm $testfile && d=1
1283         fi >& /dev/null
1284
1285         local res="$c $d"
1286         local expected=$(get_cr_del_expected $key)
1287         [ "$res" != "$expected" ] &&
1288                 error "test $key, wanted $expected, got $res" && rc=$((rc + 1))
1289         return $rc
1290 }
1291
1292 nodemap_check_quota() {
1293         local run_u="$1"
1294         $run_u lfs quota -q $DIR | awk '{ print $2; exit; }'
1295 }
1296
1297 do_fops_quota_test() {
1298         local run_u=$1
1299         # fuzz quota used to account for possible indirect blocks, etc
1300         local quota_fuzz=$(fs_log_size)
1301         local qused_orig=$(nodemap_check_quota "$run_u")
1302         local qused_high=$((qused_orig + quota_fuzz))
1303         local qused_low=$((qused_orig - quota_fuzz))
1304         local testfile=$DIR/$tdir/$tfile
1305         $run_u dd if=/dev/zero of=$testfile oflag=sync bs=1M count=1 \
1306                 >& /dev/null || error "unable to write quota test file"
1307         sync; sync_all_data || true
1308
1309         local qused_new=$(nodemap_check_quota "$run_u")
1310         [ $((qused_new)) -lt $((qused_low + 1024)) -o \
1311           $((qused_new)) -gt $((qused_high + 1024)) ] &&
1312                 error "$qused_new != $qused_orig + 1M after write, " \
1313                       "fuzz is $quota_fuzz"
1314         $run_u rm $testfile || error "unable to remove quota test file"
1315         wait_delete_completed_mds
1316
1317         qused_new=$(nodemap_check_quota "$run_u")
1318         [ $((qused_new)) -lt $((qused_low)) \
1319                 -o $((qused_new)) -gt $((qused_high)) ] &&
1320                 error "quota not reclaimed, expect $qused_orig, " \
1321                       "got $qused_new, fuzz $quota_fuzz"
1322 }
1323
1324 get_fops_mapped_user() {
1325         local cli_user=$1
1326
1327         for ((i=0; i < ${#FOPS_IDMAPS[@]}; i++)); do
1328                 for map in ${FOPS_IDMAPS[i]}; do
1329                         if [ $(cut -d: -f1 <<< "$map") == $cli_user ]; then
1330                                 cut -d: -f2 <<< "$map"
1331                                 return
1332                         fi
1333                 done
1334         done
1335         echo -1
1336 }
1337
1338 get_cr_del_expected() {
1339         local -a key
1340         IFS=":" read -a key <<< "$1"
1341         local mapmode="${key[0]}"
1342         local mds_user="${key[1]}"
1343         local cluster="${key[2]}"
1344         local cli_user="${key[3]}"
1345         local mode="0${key[4]}"
1346         local SUCCESS="1 1"
1347         local FAILURE="0 0"
1348         local noadmin=0
1349         local mapped=0
1350         local other=0
1351
1352         [[ $mapmode == *mapped* ]] && mapped=1
1353         # only c1 is mapped in these test cases
1354         [[ $mapmode == mapped_trusted* ]] && [ "$cluster" == "c0" ] && mapped=0
1355         [[ $mapmode == *noadmin* ]] && noadmin=1
1356
1357         # o+wx works as long as the user isn't mapped
1358         if [ $((mode & 3)) -eq 3 ]; then
1359                 other=1
1360         fi
1361
1362         # if client user is root, check if root is squashed
1363         if [ "$cli_user" == "0" ]; then
1364                 # squash root succeed, if other bit is on
1365                 case $noadmin in
1366                         0) echo $SUCCESS;;
1367                         1) [ "$other" == "1" ] && echo $SUCCESS
1368                            [ "$other" == "0" ] && echo $FAILURE;;
1369                 esac
1370                 return
1371         fi
1372         if [ "$mapped" == "0" ]; then
1373                 [ "$other" == "1" ] && echo $SUCCESS
1374                 [ "$other" == "0" ] && echo $FAILURE
1375                 return
1376         fi
1377
1378         # if mapped user is mds user, check for u+wx
1379         mapped_user=$(get_fops_mapped_user $cli_user)
1380         [ "$mapped_user" == "-1" ] &&
1381                 error "unable to find mapping for client user $cli_user"
1382
1383         if [ "$mapped_user" == "$mds_user" -a \
1384              $(((mode & 0300) == 0300)) -eq 1 ]; then
1385                 echo $SUCCESS
1386                 return
1387         fi
1388         if [ "$mapped_user" != "$mds_user" -a "$other" == "1" ]; then
1389                 echo $SUCCESS
1390                 return
1391         fi
1392         echo $FAILURE
1393 }
1394
1395 test_fops_admin_cli_i=""
1396 test_fops_chmod_dir() {
1397         local current_cli_i=$1
1398         local perm_bits=$2
1399         local dir_to_chmod=$3
1400         local new_admin_cli_i=""
1401
1402         # do we need to set up a new admin client?
1403         [ "$current_cli_i" == "0" ] && [ "$test_fops_admin_cli_i" != "1" ] &&
1404                 new_admin_cli_i=1
1405         [ "$current_cli_i" != "0" ] && [ "$test_fops_admin_cli_i" != "0" ] &&
1406                 new_admin_cli_i=0
1407
1408         # if only one client, and non-admin, need to flip admin everytime
1409         if [ "$num_clients" == "1" ]; then
1410                 test_fops_admin_client=$clients
1411                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1412                         nodemap.c0.admin_nodemap)
1413                 if [ "$test_fops_admin_val" != "1" ]; then
1414                         do_facet mgs $LCTL nodemap_modify \
1415                                 --name c0 \
1416                                 --property admin \
1417                                 --value 1
1418                         wait_nm_sync c0 admin_nodemap
1419                 fi
1420         elif [ "$new_admin_cli_i" != "" ]; then
1421                 # restore admin val to old admin client
1422                 if [ "$test_fops_admin_cli_i" != "" ] &&
1423                                 [ "$test_fops_admin_val" != "1" ]; then
1424                         do_facet mgs $LCTL nodemap_modify \
1425                                 --name c${test_fops_admin_cli_i} \
1426                                 --property admin \
1427                                 --value $test_fops_admin_val
1428                         wait_nm_sync c${test_fops_admin_cli_i} admin_nodemap
1429                 fi
1430
1431                 test_fops_admin_cli_i=$new_admin_cli_i
1432                 test_fops_admin_client=${clients_arr[$new_admin_cli_i]}
1433                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1434                         nodemap.c${new_admin_cli_i}.admin_nodemap)
1435
1436                 if [ "$test_fops_admin_val" != "1" ]; then
1437                         do_facet mgs $LCTL nodemap_modify \
1438                                 --name c${new_admin_cli_i} \
1439                                 --property admin \
1440                                 --value 1
1441                         wait_nm_sync c${new_admin_cli_i} admin_nodemap
1442                 fi
1443         fi
1444
1445         do_node $test_fops_admin_client chmod $perm_bits $DIR/$tdir || return 1
1446
1447         # remove admin for single client if originally non-admin
1448         if [ "$num_clients" == "1" ] && [ "$test_fops_admin_val" != "1" ]; then
1449                 do_facet mgs $LCTL nodemap_modify --name c0 --property admin \
1450                         --value 0
1451                 wait_nm_sync c0 admin_nodemap
1452         fi
1453
1454         return 0
1455 }
1456
1457 test_fops() {
1458         local mapmode="$1"
1459         local single_client="$2"
1460         local client_user_list=([0]="0 $((IDBASE+3)) $((IDBASE+4))"
1461                                 [1]="0 $((IDBASE+5)) $((IDBASE+6))")
1462         local mds_i
1463         local rc=0
1464         local perm_bit_list="0 3 $((0300)) $((0303))"
1465         # SLOW tests 000-007, 010-070, 100-700 (octal modes)
1466         [ "$SLOW" == "yes" ] &&
1467                 perm_bit_list="0 $(seq 1 7) $(seq 8 8 63) $(seq 64 64 511) \
1468                                $((0303))"
1469
1470         # step through mds users. -1 means root
1471         for mds_i in -1 0 1 2; do
1472                 local user=$((mds_i + IDBASE))
1473                 local client
1474                 local x
1475
1476                 [ "$mds_i" == "-1" ] && user=0
1477
1478                 echo mkdir -p $DIR/$tdir
1479                 fops_test_setup
1480                 local cli_i=0
1481                 for client in $clients; do
1482                         local u
1483                         for u in ${client_user_list[$cli_i]}; do
1484                                 local run_u="do_node $client \
1485                                              $RUNAS_CMD -u$u -g$u -G$u"
1486                                 for perm_bits in $perm_bit_list; do
1487                                         local mode=$(printf %03o $perm_bits)
1488                                         local key
1489                                         key="$mapmode:$user:c$cli_i:$u:$mode"
1490                                         test_fops_chmod_dir $cli_i $mode \
1491                                                 $DIR/$tdir ||
1492                                                         error cannot chmod $key
1493                                         do_create_delete "$run_u" "$key"
1494                                 done
1495
1496                                 # check quota
1497                                 test_fops_chmod_dir $cli_i 777 $DIR/$tdir ||
1498                                         error cannot chmod $key
1499                                 do_fops_quota_test "$run_u"
1500                         done
1501
1502                         cli_i=$((cli_i + 1))
1503                         [ "$single_client" == "1" ] && break
1504                 done
1505                 rm -rf $DIR/$tdir
1506         done
1507         return $rc
1508 }
1509
1510 nodemap_version_check () {
1511         remote_mgs_nodsh && skip "remote MGS with nodsh" && return 1
1512         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
1513                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
1514                 return 1
1515         return 0
1516 }
1517
1518 nodemap_test_setup() {
1519         local rc
1520         local active_nodemap=1
1521
1522         [ "$1" == "0" ] && active_nodemap=0
1523
1524         do_nodes $(comma_list $(all_mdts_nodes)) \
1525                 $LCTL set_param mdt.*.identity_upcall=NONE
1526
1527         rc=0
1528         create_fops_nodemaps
1529         rc=$?
1530         [[ $rc != 0 ]] && error "adding fops nodemaps failed $rc"
1531
1532         do_facet mgs $LCTL nodemap_activate $active_nodemap
1533         wait_nm_sync active
1534
1535         do_facet mgs $LCTL nodemap_modify --name default \
1536                 --property admin --value 1
1537         wait_nm_sync default admin_nodemap
1538         do_facet mgs $LCTL nodemap_modify --name default \
1539                 --property trusted --value 1
1540         wait_nm_sync default trusted_nodemap
1541 }
1542
1543 nodemap_test_cleanup() {
1544         trap 0
1545         delete_fops_nodemaps
1546         rc=$?
1547         [[ $rc != 0 ]] && error "removing fops nodemaps failed $rc"
1548
1549         do_facet mgs $LCTL nodemap_modify --name default \
1550                  --property admin --value 0
1551         wait_nm_sync default admin_nodemap
1552         do_facet mgs $LCTL nodemap_modify --name default \
1553                  --property trusted --value 0
1554         wait_nm_sync default trusted_nodemap
1555
1556         do_facet mgs $LCTL nodemap_activate 0
1557         wait_nm_sync active 0
1558
1559         export SK_UNIQUE_NM=false
1560         return 0
1561 }
1562
1563 nodemap_clients_admin_trusted() {
1564         local admin=$1
1565         local tr=$2
1566         local i=0
1567         for client in $clients; do
1568                 do_facet mgs $LCTL nodemap_modify --name c0 \
1569                         --property admin --value $admin
1570                 do_facet mgs $LCTL nodemap_modify --name c0 \
1571                         --property trusted --value $tr
1572                 i=$((i + 1))
1573         done
1574         wait_nm_sync c$((i - 1)) admin_nodemap
1575         wait_nm_sync c$((i - 1)) trusted_nodemap
1576 }
1577
1578 test_16() {
1579         nodemap_version_check || return 0
1580         nodemap_test_setup 0
1581
1582         trap nodemap_test_cleanup EXIT
1583         test_fops all_off
1584         nodemap_test_cleanup
1585 }
1586 run_test 16 "test nodemap all_off fileops"
1587
1588 test_17() {
1589         if $SHARED_KEY &&
1590         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1591                 skip "Need MDS >= 2.11.55"
1592         fi
1593
1594         nodemap_version_check || return 0
1595         nodemap_test_setup
1596
1597         trap nodemap_test_cleanup EXIT
1598         nodemap_clients_admin_trusted 0 1
1599         test_fops trusted_noadmin 1
1600         nodemap_test_cleanup
1601 }
1602 run_test 17 "test nodemap trusted_noadmin fileops"
1603
1604 test_18() {
1605         if $SHARED_KEY &&
1606         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1607                 skip "Need MDS >= 2.11.55"
1608         fi
1609
1610         nodemap_version_check || return 0
1611         nodemap_test_setup
1612
1613         trap nodemap_test_cleanup EXIT
1614         nodemap_clients_admin_trusted 0 0
1615         test_fops mapped_noadmin 1
1616         nodemap_test_cleanup
1617 }
1618 run_test 18 "test nodemap mapped_noadmin fileops"
1619
1620 test_19() {
1621         if $SHARED_KEY &&
1622         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1623                 skip "Need MDS >= 2.11.55"
1624         fi
1625
1626         nodemap_version_check || return 0
1627         nodemap_test_setup
1628
1629         trap nodemap_test_cleanup EXIT
1630         nodemap_clients_admin_trusted 1 1
1631         test_fops trusted_admin 1
1632         nodemap_test_cleanup
1633 }
1634 run_test 19 "test nodemap trusted_admin fileops"
1635
1636 test_20() {
1637         if $SHARED_KEY &&
1638         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1639                 skip "Need MDS >= 2.11.55"
1640         fi
1641
1642         nodemap_version_check || return 0
1643         nodemap_test_setup
1644
1645         trap nodemap_test_cleanup EXIT
1646         nodemap_clients_admin_trusted 1 0
1647         test_fops mapped_admin 1
1648         nodemap_test_cleanup
1649 }
1650 run_test 20 "test nodemap mapped_admin fileops"
1651
1652 test_21() {
1653         if $SHARED_KEY &&
1654         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1655                 skip "Need MDS >= 2.11.55"
1656         fi
1657
1658         nodemap_version_check || return 0
1659         nodemap_test_setup
1660
1661         trap nodemap_test_cleanup EXIT
1662         local x=1
1663         local i=0
1664         for client in $clients; do
1665                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1666                         --property admin --value 0
1667                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1668                         --property trusted --value $x
1669                 x=0
1670                 i=$((i + 1))
1671         done
1672         wait_nm_sync c$((i - 1)) trusted_nodemap
1673
1674         test_fops mapped_trusted_noadmin
1675         nodemap_test_cleanup
1676 }
1677 run_test 21 "test nodemap mapped_trusted_noadmin fileops"
1678
1679 test_22() {
1680         if $SHARED_KEY &&
1681         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.55) ]; then
1682                 skip "Need MDS >= 2.11.55"
1683         fi
1684
1685         nodemap_version_check || return 0
1686         nodemap_test_setup
1687
1688         trap nodemap_test_cleanup EXIT
1689         local x=1
1690         local i=0
1691         for client in $clients; do
1692                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1693                         --property admin --value 1
1694                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1695                         --property trusted --value $x
1696                 x=0
1697                 i=$((i + 1))
1698         done
1699         wait_nm_sync c$((i - 1)) trusted_nodemap
1700
1701         test_fops mapped_trusted_admin
1702         nodemap_test_cleanup
1703 }
1704 run_test 22 "test nodemap mapped_trusted_admin fileops"
1705
1706 # acl test directory needs to be initialized on a privileged client
1707 nodemap_acl_test_setup() {
1708         local admin=$(do_facet mgs $LCTL get_param -n \
1709                       nodemap.c0.admin_nodemap)
1710         local trust=$(do_facet mgs $LCTL get_param -n \
1711                       nodemap.c0.trusted_nodemap)
1712
1713         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1714         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1715
1716         wait_nm_sync c0 admin_nodemap
1717         wait_nm_sync c0 trusted_nodemap
1718
1719         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1720         nm_test_mkdir
1721         do_node ${clients_arr[0]} chmod a+rwx $DIR/$tdir ||
1722                 error unable to chmod a+rwx test dir $DIR/$tdir
1723
1724         do_facet mgs $LCTL nodemap_modify --name c0 \
1725                 --property admin --value $admin
1726         do_facet mgs $LCTL nodemap_modify --name c0 \
1727                 --property trusted --value $trust
1728
1729         wait_nm_sync c0 trusted_nodemap
1730 }
1731
1732 # returns 0 if the number of ACLs does not change on the second (mapped) client
1733 # after being set on the first client
1734 nodemap_acl_test() {
1735         local user="$1"
1736         local set_client="$2"
1737         local get_client="$3"
1738         local check_setfacl="$4"
1739         local setfacl_error=0
1740         local testfile=$DIR/$tdir/$tfile
1741         local RUNAS_USER="$RUNAS_CMD -u $user"
1742         local acl_count=0
1743         local acl_count_post=0
1744
1745         nodemap_acl_test_setup
1746         sleep 5
1747
1748         do_node $set_client $RUNAS_USER touch $testfile
1749
1750         # ACL masks aren't filtered by nodemap code, so we ignore them
1751         acl_count=$(do_node $get_client getfacl $testfile | grep -v mask |
1752                 wc -l)
1753         do_node $set_client $RUNAS_USER setfacl -m $user:rwx $testfile ||
1754                 setfacl_error=1
1755
1756         # if check setfacl is set to 1, then it's supposed to error
1757         if [ "$check_setfacl" == "1" ]; then
1758                 [ "$setfacl_error" != "1" ] && return 1
1759                 return 0
1760         fi
1761         [ "$setfacl_error" == "1" ] && echo "WARNING: unable to setfacl"
1762
1763         acl_count_post=$(do_node $get_client getfacl $testfile | grep -v mask |
1764                 wc -l)
1765         [ $acl_count -eq $acl_count_post ] && return 0
1766         return 1
1767 }
1768
1769 test_23a() {
1770         [ $num_clients -lt 2 ] && skip "Need 2 clients at least" && return
1771         nodemap_version_check || return 0
1772         nodemap_test_setup
1773
1774         trap nodemap_test_cleanup EXIT
1775         # 1 trusted cluster, 1 mapped cluster
1776         local unmapped_fs=$((IDBASE+0))
1777         local unmapped_c1=$((IDBASE+5))
1778         local mapped_fs=$((IDBASE+2))
1779         local mapped_c0=$((IDBASE+4))
1780         local mapped_c1=$((IDBASE+6))
1781
1782         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1783         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1784
1785         do_facet mgs $LCTL nodemap_modify --name c1 --property admin --value 0
1786         do_facet mgs $LCTL nodemap_modify --name c1 --property trusted --value 0
1787
1788         wait_nm_sync c1 trusted_nodemap
1789
1790         # setfacl on trusted cluster to unmapped user, verify it's not seen
1791         nodemap_acl_test $unmapped_fs ${clients_arr[0]} ${clients_arr[1]} ||
1792                 error "acl count (1)"
1793
1794         # setfacl on trusted cluster to mapped user, verify it's seen
1795         nodemap_acl_test $mapped_fs ${clients_arr[0]} ${clients_arr[1]} &&
1796                 error "acl count (2)"
1797
1798         # setfacl on mapped cluster to mapped user, verify it's seen
1799         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1800                 error "acl count (3)"
1801
1802         # setfacl on mapped cluster to unmapped user, verify error
1803         nodemap_acl_test $unmapped_fs ${clients_arr[1]} ${clients_arr[0]} 1 ||
1804                 error "acl count (4)"
1805
1806         # 2 mapped clusters
1807         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 0
1808         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 0
1809
1810         wait_nm_sync c0 trusted_nodemap
1811
1812         # setfacl to mapped user on c1, also mapped to c0, verify it's seen
1813         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1814                 error "acl count (5)"
1815
1816         # setfacl to mapped user on c1, not mapped to c0, verify not seen
1817         nodemap_acl_test $unmapped_c1 ${clients_arr[1]} ${clients_arr[0]} ||
1818                 error "acl count (6)"
1819
1820         nodemap_test_cleanup
1821 }
1822 run_test 23a "test mapped regular ACLs"
1823
1824 test_23b() { #LU-9929
1825         [ $num_clients -lt 2 ] && skip "Need 2 clients at least" && return
1826         [ $(lustre_version_code mgs) -lt $(version_code 2.10.53) ] &&
1827                 skip "Need MGS >= 2.10.53" && return
1828
1829         export SK_UNIQUE_NM=true
1830         nodemap_test_setup
1831         trap nodemap_test_cleanup EXIT
1832
1833         local testdir=$DIR/$tdir
1834         local fs_id=$((IDBASE+10))
1835         local unmapped_id
1836         local mapped_id
1837         local fs_user
1838
1839         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1840         wait_nm_sync c0 admin_nodemap
1841         do_facet mgs $LCTL nodemap_modify --name c1 --property admin --value 1
1842         wait_nm_sync c1 admin_nodemap
1843         do_facet mgs $LCTL nodemap_modify --name c1 --property trusted --value 1
1844         wait_nm_sync c1 trusted_nodemap
1845
1846         # Add idmap $ID0:$fs_id (500:60010)
1847         do_facet mgs $LCTL nodemap_add_idmap --name c0 --idtype gid \
1848                 --idmap $ID0:$fs_id ||
1849                 error "add idmap $ID0:$fs_id to nodemap c0 failed"
1850         wait_nm_sync c0 idmap
1851
1852         # set/getfacl default acl on client 1 (unmapped gid=500)
1853         do_node ${clients_arr[0]} rm -rf $testdir
1854         do_node ${clients_arr[0]} mkdir -p $testdir
1855         # Here, USER0=$(getent passwd | grep :$ID0:$ID0: | cut -d: -f1)
1856         do_node ${clients_arr[0]} setfacl -R -d -m group:$USER0:rwx $testdir ||
1857                 error "setfacl $testdir on ${clients_arr[0]} failed"
1858         unmapped_id=$(do_node ${clients_arr[0]} getfacl $testdir |
1859                         grep -E "default:group:.*:rwx" | awk -F: '{print $3}')
1860         [ "$unmapped_id" = "$USER0" ] ||
1861                 error "gid=$ID0 was not unmapped correctly on ${clients_arr[0]}"
1862
1863         # getfacl default acl on client 2 (mapped gid=60010)
1864         mapped_id=$(do_node ${clients_arr[1]} getfacl $testdir |
1865                         grep -E "default:group:.*:rwx" | awk -F: '{print $3}')
1866         fs_user=$(do_node ${clients_arr[1]} getent passwd |
1867                         grep :$fs_id:$fs_id: | cut -d: -f1)
1868         [ -z "$fs_user" ] && fs_user=$fs_id
1869         [ $mapped_id -eq $fs_id -o "$mapped_id" = "$fs_user" ] ||
1870                 error "Should return gid=$fs_id or $fs_user on client2"
1871
1872         rm -rf $testdir
1873         nodemap_test_cleanup
1874         export SK_UNIQUE_NM=false
1875 }
1876 run_test 23b "test mapped default ACLs"
1877
1878 test_24() {
1879         nodemap_test_setup
1880
1881         trap nodemap_test_cleanup EXIT
1882         do_nodes $(comma_list $(all_server_nodes)) $LCTL get_param -R nodemap
1883
1884         nodemap_test_cleanup
1885 }
1886 run_test 24 "check nodemap proc files for LBUGs and Oopses"
1887
1888 test_25() {
1889         local tmpfile=$(mktemp)
1890         local tmpfile2=$(mktemp)
1891         local tmpfile3=$(mktemp)
1892         local tmpfile4=$(mktemp)
1893         local subdir=c0dir
1894         local client
1895
1896         nodemap_version_check || return 0
1897
1898         # stop clients for this test
1899         zconf_umount_clients $CLIENTS $MOUNT ||
1900             error "unable to umount clients $CLIENTS"
1901
1902         export SK_UNIQUE_NM=true
1903         nodemap_test_setup
1904
1905         # enable trusted/admin for setquota call in cleanup_and_setup_lustre()
1906         i=0
1907         for client in $clients; do
1908                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1909                         --property admin --value 1
1910                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1911                         --property trusted --value 1
1912                 ((i++))
1913         done
1914         wait_nm_sync c$((i - 1)) trusted_nodemap
1915
1916         trap nodemap_test_cleanup EXIT
1917
1918         # create a new, empty nodemap, and add fileset info to it
1919         do_facet mgs $LCTL nodemap_add test25 ||
1920                 error "unable to create nodemap $testname"
1921         do_facet mgs $LCTL set_param -P nodemap.$testname.fileset=/$subdir ||
1922                 error "unable to add fileset info to nodemap test25"
1923
1924         wait_nm_sync test25 id
1925
1926         do_facet mgs $LCTL nodemap_info > $tmpfile
1927         do_facet mds $LCTL nodemap_info > $tmpfile2
1928
1929         if ! $SHARED_KEY; then
1930                 # will conflict with SK's nodemaps
1931                 cleanup_and_setup_lustre
1932         fi
1933         # stop clients for this test
1934         zconf_umount_clients $CLIENTS $MOUNT ||
1935             error "unable to umount clients $CLIENTS"
1936
1937         do_facet mgs $LCTL nodemap_info > $tmpfile3
1938         diff -q $tmpfile3 $tmpfile >& /dev/null ||
1939                 error "nodemap_info diff on MGS after remount"
1940
1941         do_facet mds $LCTL nodemap_info > $tmpfile4
1942         diff -q $tmpfile4 $tmpfile2 >& /dev/null ||
1943                 error "nodemap_info diff on MDS after remount"
1944
1945         # cleanup nodemap
1946         do_facet mgs $LCTL nodemap_del test25 ||
1947             error "cannot delete nodemap test25 from config"
1948         nodemap_test_cleanup
1949         # restart clients previously stopped
1950         zconf_mount_clients $CLIENTS $MOUNT ||
1951             error "unable to mount clients $CLIENTS"
1952
1953         rm -f $tmpfile $tmpfile2
1954         export SK_UNIQUE_NM=false
1955 }
1956 run_test 25 "test save and reload nodemap config"
1957
1958 test_26() {
1959         nodemap_version_check || return 0
1960
1961         local large_i=32000
1962
1963         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_add"
1964         wait_nm_sync c$large_i admin_nodemap
1965
1966         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_del"
1967         wait_nm_sync c$large_i admin_nodemap
1968 }
1969 run_test 26 "test transferring very large nodemap"
1970
1971 nodemap_exercise_fileset() {
1972         local nm="$1"
1973         local loop=0
1974
1975         # setup
1976         if [ "$nm" == "default" ]; then
1977                 do_facet mgs $LCTL nodemap_activate 1
1978                 wait_nm_sync active
1979         else
1980                 nodemap_test_setup
1981         fi
1982         if $SHARED_KEY; then
1983                 export SK_UNIQUE_NM=true
1984         else
1985                 # will conflict with SK's nodemaps
1986                 trap "fileset_test_cleanup $nm" EXIT
1987         fi
1988         fileset_test_setup "$nm"
1989
1990         # add fileset info to $nm nodemap
1991         if ! combined_mgs_mds; then
1992             do_facet mgs $LCTL set_param nodemap.${nm}.fileset=/$subdir ||
1993                 error "unable to add fileset info to $nm nodemap on MGS"
1994         fi
1995         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=/$subdir ||
1996                error "unable to add fileset info to $nm nodemap for servers"
1997         wait_nm_sync $nm fileset "nodemap.${nm}.fileset=/$subdir"
1998
1999         # re-mount client
2000         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2001                 error "unable to umount client ${clients_arr[0]}"
2002         # set some generic fileset to trigger SSK code
2003         export FILESET=/
2004         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2005                 error "unable to remount client ${clients_arr[0]}"
2006         unset FILESET
2007
2008         # test mount point content
2009         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subdir ||
2010                 error "fileset not taken into account"
2011
2012         # re-mount client with sub-subdir
2013         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2014                 error "unable to umount client ${clients_arr[0]}"
2015         export FILESET=/$subsubdir
2016         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2017                 error "unable to remount client ${clients_arr[0]}"
2018         unset FILESET
2019
2020         # test mount point content
2021         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subsubdir ||
2022                 error "subdir of fileset not taken into account"
2023
2024         # remove fileset info from nodemap
2025         do_facet mgs $LCTL nodemap_set_fileset --name $nm --fileset clear ||
2026                 error "unable to delete fileset info on $nm nodemap"
2027         wait_update_facet mgs "$LCTL get_param nodemap.${nm}.fileset" \
2028                           "nodemap.${nm}.fileset=" ||
2029                 error "fileset info still not cleared on $nm nodemap"
2030         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=clear ||
2031                 error "unable to reset fileset info on $nm nodemap"
2032         wait_nm_sync $nm fileset "nodemap.${nm}.fileset="
2033
2034         # re-mount client
2035         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2036                 error "unable to umount client ${clients_arr[0]}"
2037         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2038                 error "unable to remount client ${clients_arr[0]}"
2039
2040         # test mount point content
2041         if ! $(do_node ${clients_arr[0]} test -d $MOUNT/$subdir); then
2042                 ls $MOUNT
2043                 error "fileset not cleared on $nm nodemap"
2044         fi
2045
2046         # back to non-nodemap setup
2047         if $SHARED_KEY; then
2048                 export SK_UNIQUE_NM=false
2049                 zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2050                         error "unable to umount client ${clients_arr[0]}"
2051         fi
2052         fileset_test_cleanup "$nm"
2053         if [ "$nm" == "default" ]; then
2054                 do_facet mgs $LCTL nodemap_activate 0
2055                 wait_nm_sync active 0
2056                 trap 0
2057                 export SK_UNIQUE_NM=false
2058         else
2059                 nodemap_test_cleanup
2060         fi
2061         if $SHARED_KEY; then
2062                 zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2063                         error "unable to remount client ${clients_arr[0]}"
2064         fi
2065 }
2066
2067 test_27a() {
2068         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.50) ] &&
2069                 skip "Need MDS >= 2.11.50" && return
2070
2071         for nm in "default" "c0"; do
2072                 local subdir="subdir_${nm}"
2073                 local subsubdir="subsubdir_${nm}"
2074
2075                 if [ "$nm" == "default" ] && [ "$SHARED_KEY" == "true" ]; then
2076                         echo "Skipping nodemap $nm with SHARED_KEY";
2077                         continue;
2078                 fi
2079
2080                 echo "Exercising fileset for nodemap $nm"
2081                 nodemap_exercise_fileset "$nm"
2082         done
2083 }
2084 run_test 27a "test fileset in various nodemaps"
2085
2086 test_27b() { #LU-10703
2087         [ $(lustre_version_code $SINGLEMDS) -lt $(version_code 2.11.50) ] &&
2088                 skip "Need MDS >= 2.11.50" && return
2089         [[ $MDSCOUNT -lt 2 ]] && skip "needs >= 2 MDTs" && return
2090
2091         nodemap_test_setup
2092         trap nodemap_test_cleanup EXIT
2093
2094         # Add the nodemaps and set their filesets
2095         for i in $(seq 1 $MDSCOUNT); do
2096                 do_facet mgs $LCTL nodemap_del nm$i 2>/dev/null
2097                 do_facet mgs $LCTL nodemap_add nm$i ||
2098                         error "add nodemap nm$i failed"
2099                 wait_nm_sync nm$i "" "" "-N"
2100
2101                 if ! combined_mgs_mds; then
2102                         do_facet mgs \
2103                                 $LCTL set_param nodemap.nm$i.fileset=/dir$i ||
2104                                 error "set nm$i.fileset=/dir$i failed on MGS"
2105                 fi
2106                 do_facet mgs $LCTL set_param -P nodemap.nm$i.fileset=/dir$i ||
2107                         error "set nm$i.fileset=/dir$i failed on servers"
2108                 wait_nm_sync nm$i fileset "nodemap.nm$i.fileset=/dir$i"
2109         done
2110
2111         # Check if all the filesets are correct
2112         for i in $(seq 1 $MDSCOUNT); do
2113                 fileset=$(do_facet mds$i \
2114                           $LCTL get_param -n nodemap.nm$i.fileset)
2115                 [ "$fileset" = "/dir$i" ] ||
2116                         error "nm$i.fileset $fileset != /dir$i on mds$i"
2117                 do_facet mgs $LCTL nodemap_del nm$i ||
2118                         error "delete nodemap nm$i failed"
2119         done
2120
2121         nodemap_test_cleanup
2122 }
2123 run_test 27b "The new nodemap won't clear the old nodemap's fileset"
2124
2125 test_28() {
2126         if ! $SHARED_KEY; then
2127                 skip "need shared key feature for this test" && return
2128         fi
2129         mkdir -p $DIR/$tdir || error "mkdir failed"
2130         touch $DIR/$tdir/$tdir.out || error "touch failed"
2131         if [ ! -f $DIR/$tdir/$tdir.out ]; then
2132                 error "read before rotation failed"
2133         fi
2134         # store top key identity to ensure rotation has occurred
2135         SK_IDENTITY_OLD=$(lctl get_param *.*.*srpc* | grep "expire" |
2136                 head -1 | awk '{print $15}' | cut -c1-8)
2137         do_facet $SINGLEMDS lfs flushctx ||
2138                  error "could not run flushctx on $SINGLEMDS"
2139         sleep 5
2140         lfs flushctx || error "could not run flushctx on client"
2141         sleep 5
2142         # verify new key is in place
2143         SK_IDENTITY_NEW=$(lctl get_param *.*.*srpc* | grep "expire" |
2144                 head -1 | awk '{print $15}' | cut -c1-8)
2145         if [ $SK_IDENTITY_OLD == $SK_IDENTITY_NEW ]; then
2146                 error "key did not rotate correctly"
2147         fi
2148         if [ ! -f $DIR/$tdir/$tdir.out ]; then
2149                 error "read after rotation failed"
2150         fi
2151 }
2152 run_test 28 "check shared key rotation method"
2153
2154 test_29() {
2155         if ! $SHARED_KEY; then
2156                 skip "need shared key feature for this test" && return
2157         fi
2158         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
2159                 skip "test only valid if integrity is active"
2160         fi
2161         rm -r $DIR/$tdir
2162         mkdir $DIR/$tdir || error "mkdir"
2163         touch $DIR/$tdir/$tfile || error "touch"
2164         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2165                 error "unable to umount clients"
2166         keyctl show | awk '/lustre/ { print $1 }' |
2167                 xargs -IX keyctl unlink X
2168         OLD_SK_PATH=$SK_PATH
2169         export SK_PATH=/dev/null
2170         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
2171                 export SK_PATH=$OLD_SK_PATH
2172                 if [ -e $DIR/$tdir/$tfile ]; then
2173                         error "able to mount and read without key"
2174                 else
2175                         error "able to mount without key"
2176                 fi
2177         else
2178                 export SK_PATH=$OLD_SK_PATH
2179                 keyctl show | awk '/lustre/ { print $1 }' |
2180                         xargs -IX keyctl unlink X
2181         fi
2182 }
2183 run_test 29 "check for missing shared key"
2184
2185 test_30() {
2186         if ! $SHARED_KEY; then
2187                 skip "need shared key feature for this test" && return
2188         fi
2189         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
2190                 skip "test only valid if integrity is active"
2191         fi
2192         mkdir -p $DIR/$tdir || error "mkdir failed"
2193         touch $DIR/$tdir/$tdir.out || error "touch failed"
2194         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2195                 error "unable to umount clients"
2196         # unload keys from ring
2197         keyctl show | awk '/lustre/ { print $1 }' |
2198                 xargs -IX keyctl unlink X
2199         # invalidate the key with bogus filesystem name
2200         lgss_sk -w $SK_PATH/$FSNAME-bogus.key -f $FSNAME.bogus \
2201                 -t client -d /dev/urandom || error "lgss_sk failed (1)"
2202         do_facet $SINGLEMDS lfs flushctx || error "could not run flushctx"
2203         OLD_SK_PATH=$SK_PATH
2204         export SK_PATH=$SK_PATH/$FSNAME-bogus.key
2205         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
2206                 SK_PATH=$OLD_SK_PATH
2207                 if [ -a $DIR/$tdir/$tdir.out ]; then
2208                         error "mount and read file with invalid key"
2209                 else
2210                         error "mount with invalid key"
2211                 fi
2212         fi
2213         SK_PATH=$OLD_SK_PATH
2214         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2215                 error "unable to umount clients"
2216 }
2217 run_test 30 "check for invalid shared key"
2218
2219 cleanup_31() {
2220         # unmount client
2221         zconf_umount $HOSTNAME $MOUNT || error "unable to umount client"
2222
2223         # remove ${NETTYPE}999 network on all nodes
2224         do_nodes $(comma_list $(all_nodes)) \
2225                  "$LNETCTL net del --net ${NETTYPE}999 && \
2226                   $LNETCTL lnet unconfigure 2>/dev/null || true"
2227
2228         # necessary to do writeconf in order to de-register
2229         # @${NETTYPE}999 nid for targets
2230         KZPOOL=$KEEP_ZPOOL
2231         export KEEP_ZPOOL="true"
2232         stopall
2233         export SK_MOUNTED=false
2234         writeconf_all
2235         setupall || echo 1
2236         export KEEP_ZPOOL="$KZPOOL"
2237 }
2238
2239 test_31() {
2240         local nid=$(lctl list_nids | grep ${NETTYPE} | head -n1)
2241         local addr=${nid%@*}
2242         local net=${nid#*@}
2243
2244         export LNETCTL=$(which lnetctl 2> /dev/null)
2245
2246         [ -z "$LNETCTL" ] && skip "without lnetctl support." && return
2247         local_mode && skip "in local mode."
2248
2249         stack_trap cleanup_31 EXIT
2250
2251         # umount client
2252         if [ "$MOUNT_2" ] && $(grep -q $MOUNT2' ' /proc/mounts); then
2253                 umount_client $MOUNT2 || error "umount $MOUNT2 failed"
2254         fi
2255         if $(grep -q $MOUNT' ' /proc/mounts); then
2256                 umount_client $MOUNT || error "umount $MOUNT failed"
2257         fi
2258
2259         # check exports on servers are empty for client
2260         do_facet mgs "lctl get_param -n *.MGS*.exports.'$nid'.uuid 2>/dev/null |
2261                       grep -q -" && error "export on MGS should be empty"
2262         do_nodes $(comma_list $(mdts_nodes) $(osts_nodes)) \
2263                  "lctl get_param -n *.${FSNAME}*.exports.'$nid'.uuid \
2264                   2>/dev/null | grep -q -" &&
2265                 error "export on servers should be empty"
2266
2267         # add network ${NETTYPE}999 on all nodes
2268         do_nodes $(comma_list $(all_nodes)) \
2269                  "$LNETCTL lnet configure && $LNETCTL net add --if \
2270                   \$($LNETCTL net show --net $net | awk 'BEGIN{inf=0} \
2271                   {if (inf==1) print \$2; fi; inf=0} /interfaces/{inf=1}') \
2272                   --net ${NETTYPE}999" ||
2273                 error "unable to configure NID ${NETTYPE}999"
2274
2275         # necessary to do writeconf in order to register
2276         # new @${NETTYPE}999 nid for targets
2277         KZPOOL=$KEEP_ZPOOL
2278         export KEEP_ZPOOL="true"
2279         stopall
2280         export SK_MOUNTED=false
2281         writeconf_all
2282         setupall server_only || echo 1
2283         export KEEP_ZPOOL="$KZPOOL"
2284
2285         # backup MGSNID
2286         local mgsnid_orig=$MGSNID
2287         # compute new MGSNID
2288         MGSNID=$(do_facet mgs "$LCTL list_nids | grep ${NETTYPE}999")
2289
2290         # on client, turn LNet Dynamic Discovery on
2291         lnetctl set discovery 1
2292
2293         # mount client with -o network=${NETTYPE}999 option:
2294         # should fail because of LNet Dynamic Discovery
2295         mount_client $MOUNT ${MOUNT_OPTS},network=${NETTYPE}999 &&
2296                 error "client mount with '-o network' option should be refused"
2297
2298         # on client, reconfigure LNet and turn LNet Dynamic Discovery off
2299         $LNETCTL net del --net ${NETTYPE}999 && lnetctl lnet unconfigure
2300         lustre_rmmod
2301         modprobe lnet
2302         lnetctl set discovery 0
2303         modprobe ptlrpc
2304         $LNETCTL lnet configure && $LNETCTL net add --if \
2305           $($LNETCTL net show --net $net | awk 'BEGIN{inf=0} \
2306           {if (inf==1) print $2; fi; inf=0} /interfaces/{inf=1}') \
2307           --net ${NETTYPE}999 ||
2308         error "unable to configure NID ${NETTYPE}999 on client"
2309
2310         # mount client with -o network=${NETTYPE}999 option
2311         mount_client $MOUNT ${MOUNT_OPTS},network=${NETTYPE}999 ||
2312                 error "unable to remount client"
2313
2314         # restore MGSNID
2315         MGSNID=$mgsnid_orig
2316
2317         # check export on MGS
2318         do_facet mgs "lctl get_param -n *.MGS*.exports.'$nid'.uuid 2>/dev/null |
2319                       grep -q -"
2320         [ $? -ne 0 ] || error "export for $nid on MGS should not exist"
2321
2322         do_facet mgs \
2323                 "lctl get_param -n *.MGS*.exports.'${addr}@${NETTYPE}999'.uuid \
2324                  2>/dev/null | grep -q -"
2325         [ $? -eq 0 ] ||
2326                 error "export for ${addr}@${NETTYPE}999 on MGS should exist"
2327
2328         # check {mdc,osc} imports
2329         lctl get_param mdc.${FSNAME}-*.import | grep current_connection |
2330             grep -q ${NETTYPE}999
2331         [ $? -eq 0 ] ||
2332                 error "import for mdc should use ${addr}@${NETTYPE}999"
2333         lctl get_param osc.${FSNAME}-*.import | grep current_connection |
2334             grep -q ${NETTYPE}999
2335         [ $? -eq 0 ] ||
2336                 error "import for osc should use ${addr}@${NETTYPE}999"
2337 }
2338 run_test 31 "client mount option '-o network'"
2339
2340 cleanup_32() {
2341         # umount client
2342         zconf_umount_clients ${clients_arr[0]} $MOUNT
2343
2344         # disable sk flavor enforcement on MGS
2345         set_rule _mgs any any null
2346
2347         # stop gss daemon on MGS
2348         if ! combined_mgs_mds ; then
2349                 send_sigint $mgs_HOST lsvcgssd
2350         fi
2351
2352         # re-mount client
2353         MOUNT_OPTS=$(add_sk_mntflag $MOUNT_OPTS)
2354         mountcli
2355
2356         restore_to_default_flavor
2357 }
2358
2359 test_32() {
2360         if ! $SHARED_KEY; then
2361                 skip "need shared key feature for this test"
2362         fi
2363
2364         stack_trap cleanup_32 EXIT
2365
2366         # restore to default null flavor
2367         save_flvr=$SK_FLAVOR
2368         SK_FLAVOR=null
2369         restore_to_default_flavor || error "cannot set null flavor"
2370         SK_FLAVOR=$save_flvr
2371
2372         # umount client
2373         if [ "$MOUNT_2" ] && $(grep -q $MOUNT2' ' /proc/mounts); then
2374                 umount_client $MOUNT2 || error "umount $MOUNT2 failed"
2375         fi
2376         if $(grep -q $MOUNT' ' /proc/mounts); then
2377         umount_client $MOUNT || error "umount $MOUNT failed"
2378         fi
2379
2380         # start gss daemon on MGS
2381         if combined_mgs_mds ; then
2382                 send_sigint $mds_HOST lsvcgssd
2383         fi
2384         start_gss_daemons $mgs_HOST "$LSVCGSSD -vvv -s -g"
2385
2386         # add mgs key type and MGS NIDs in key on MGS
2387         do_nodes $mgs_HOST "lgss_sk -t mgs,server -g $MGSNID -m \
2388                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2389                 error "could not modify keyfile on MGS"
2390
2391         # load modified key file on MGS
2392         do_nodes $mgs_HOST "lgss_sk -l $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2393                 error "could not load keyfile on MGS"
2394
2395         # add MGS NIDs in key on client
2396         do_nodes ${clients_arr[0]} "lgss_sk -g $MGSNID -m \
2397                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2398                 error "could not modify keyfile on MGS"
2399
2400         # set perms for per-nodemap keys else permission denied
2401         do_nodes $(comma_list $(all_nodes)) \
2402                  "keyctl show | grep lustre | cut -c1-11 |
2403                                 sed -e 's/ //g;' |
2404                                 xargs -IX keyctl setperm X 0x3f3f3f3f"
2405
2406         # re-mount client with mgssec=skn
2407         save_opts=$MOUNT_OPTS
2408         if [ -z "$MOUNT_OPTS" ]; then
2409                 MOUNT_OPTS="-o mgssec=skn"
2410         else
2411                 MOUNT_OPTS="$MOUNT_OPTS,mgssec=skn"
2412         fi
2413         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2414                 error "mount ${clients_arr[0]} with mgssec=skn failed"
2415         MOUNT_OPTS=$save_opts
2416
2417         # umount client
2418         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2419                 error "umount ${clients_arr[0]} failed"
2420
2421         # enforce ska flavor on MGS
2422         set_rule _mgs any any ska
2423
2424         # re-mount client without mgssec
2425         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS &&
2426                 error "mount ${clients_arr[0]} without mgssec should fail"
2427
2428         # re-mount client with mgssec=skn
2429         save_opts=$MOUNT_OPTS
2430         if [ -z "$MOUNT_OPTS" ]; then
2431                 MOUNT_OPTS="-o mgssec=skn"
2432         else
2433                 MOUNT_OPTS="$MOUNT_OPTS,mgssec=skn"
2434         fi
2435         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS &&
2436                 error "mount ${clients_arr[0]} with mgssec=skn should fail"
2437         MOUNT_OPTS=$save_opts
2438
2439         # re-mount client with mgssec=ska
2440         save_opts=$MOUNT_OPTS
2441         if [ -z "$MOUNT_OPTS" ]; then
2442                 MOUNT_OPTS="-o mgssec=ska"
2443         else
2444                 MOUNT_OPTS="$MOUNT_OPTS,mgssec=ska"
2445         fi
2446         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2447                 error "mount ${clients_arr[0]} with mgssec=ska failed"
2448         MOUNT_OPTS=$save_opts
2449
2450         exit 0
2451 }
2452 run_test 32 "check for mgssec"
2453
2454 cleanup_33() {
2455         # disable sk flavor enforcement
2456         set_rule $FSNAME any cli2mdt null
2457         wait_flavor cli2mdt null
2458
2459         # umount client
2460         zconf_umount_clients ${clients_arr[0]} $MOUNT
2461
2462         # stop gss daemon on MGS
2463         if ! combined_mgs_mds ; then
2464                 send_sigint $mgs_HOST lsvcgssd
2465         fi
2466
2467         # re-mount client
2468         MOUNT_OPTS=$(add_sk_mntflag $MOUNT_OPTS)
2469         mountcli
2470
2471         restore_to_default_flavor
2472 }
2473
2474 test_33() {
2475         if ! $SHARED_KEY; then
2476                 skip "need shared key feature for this test"
2477         fi
2478
2479         stack_trap cleanup_33 EXIT
2480
2481         # restore to default null flavor
2482         save_flvr=$SK_FLAVOR
2483         SK_FLAVOR=null
2484         restore_to_default_flavor || error "cannot set null flavor"
2485         SK_FLAVOR=$save_flvr
2486
2487         # umount client
2488         if [ "$MOUNT_2" ] && $(grep -q $MOUNT2' ' /proc/mounts); then
2489                 umount_client $MOUNT2 || error "umount $MOUNT2 failed"
2490         fi
2491         if $(grep -q $MOUNT' ' /proc/mounts); then
2492         umount_client $MOUNT || error "umount $MOUNT failed"
2493         fi
2494
2495         # start gss daemon on MGS
2496         if combined_mgs_mds ; then
2497                 send_sigint $mds_HOST lsvcgssd
2498         fi
2499         start_gss_daemons $mgs_HOST "$LSVCGSSD -vvv -s -g"
2500
2501         # add mgs key type and MGS NIDs in key on MGS
2502         do_nodes $mgs_HOST "lgss_sk -t mgs,server -g $MGSNID -m \
2503                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2504                 error "could not modify keyfile on MGS"
2505
2506         # load modified key file on MGS
2507         do_nodes $mgs_HOST "lgss_sk -l $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2508                 error "could not load keyfile on MGS"
2509
2510         # add MGS NIDs in key on client
2511         do_nodes ${clients_arr[0]} "lgss_sk -g $MGSNID -m \
2512                                 $SK_PATH/$FSNAME.key >/dev/null 2>&1" ||
2513                 error "could not modify keyfile on MGS"
2514
2515         # set perms for per-nodemap keys else permission denied
2516         do_nodes $(comma_list $(all_nodes)) \
2517                  "keyctl show | grep lustre | cut -c1-11 |
2518                                 sed -e 's/ //g;' |
2519                                 xargs -IX keyctl setperm X 0x3f3f3f3f"
2520
2521         # re-mount client with mgssec=skn
2522         save_opts=$MOUNT_OPTS
2523         if [ -z "$MOUNT_OPTS" ]; then
2524                 MOUNT_OPTS="-o mgssec=skn"
2525         else
2526                 MOUNT_OPTS="$MOUNT_OPTS,mgssec=skn"
2527         fi
2528         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
2529                 error "mount ${clients_arr[0]} with mgssec=skn failed"
2530         MOUNT_OPTS=$save_opts
2531
2532         # enforce ska flavor for cli2mdt
2533         set_rule $FSNAME any cli2mdt ska
2534         wait_flavor cli2mdt ska
2535
2536         # check error message
2537         $LCTL dk | grep "faked source" &&
2538                 error "MGS connection srpc flags incorrect"
2539
2540         exit 0
2541 }
2542 run_test 33 "correct srpc flags for MGS connection"
2543
2544 cleanup_34_deny() {
2545         # restore deny_unknown
2546         do_facet mgs $LCTL nodemap_modify --name default \
2547                            --property deny_unknown --value $denydefault
2548         if [ $? -ne 0 ]; then
2549                 error_noexit "cannot reset deny_unknown on default nodemap"
2550                 return
2551         fi
2552
2553         wait_nm_sync default deny_unknown
2554 }
2555
2556 test_34() {
2557         local denynew
2558         local activedefault
2559
2560         [ $MGS_VERSION -lt $(version_code 2.12.51) ] &&
2561                 skip "deny_unknown on default nm not supported before 2.12.51"
2562
2563         activedefault=$(do_facet mgs $LCTL get_param -n nodemap.active)
2564
2565         if [[ "$activedefault" != "1" ]]; then
2566                 do_facet mgs $LCTL nodemap_activate 1
2567                 wait_nm_sync active
2568                 stack_trap cleanup_active EXIT
2569         fi
2570
2571         denydefault=$(do_facet mgs $LCTL get_param -n \
2572                       nodemap.default.deny_unknown)
2573         [ -z "$denydefault" ] &&
2574                 error "cannot get deny_unknown on default nodemap"
2575         if [ "$denydefault" -eq 0 ]; then
2576                 denynew=1;
2577         else
2578                 denynew=0;
2579         fi
2580
2581         do_facet mgs $LCTL nodemap_modify --name default \
2582                         --property deny_unknown --value $denynew ||
2583                 error "cannot set deny_unknown on default nodemap"
2584
2585         [ "$(do_facet mgs $LCTL get_param -n nodemap.default.deny_unknown)" \
2586                         -eq $denynew ] ||
2587                 error "setting deny_unknown on default nodemap did not work"
2588
2589         stack_trap cleanup_34_deny EXIT
2590
2591         wait_nm_sync default deny_unknown
2592 }
2593 run_test 34 "deny_unknown on default nodemap"
2594
2595 log "cleanup: ======================================================"
2596
2597 sec_unsetup() {
2598         for num in $(seq $MDSCOUNT); do
2599                 if [ "${identity_old[$num]}" = 1 ]; then
2600                         switch_identity $num false || identity_old[$num]=$?
2601                 fi
2602         done
2603
2604         $RUNAS_CMD -u $ID0 ls $DIR
2605         $RUNAS_CMD -u $ID1 ls $DIR
2606 }
2607 sec_unsetup
2608
2609 complete $SECONDS
2610 check_and_cleanup_lustre
2611 exit_status