lustre/tests/sanity-sec.sh

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