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: LU-10229
  11 ALWAYS_EXCEPT="                27 $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_11() {
 782         local rc
 783
 784         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 785         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 786                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 787                 return
 788
 789         rc=0
 790         create_nodemaps
 791         rc=$?
 792         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 793
 794         rc=0
 795         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 796                 if ! modify_flags ${HOSTNAME_CHECKSUM}_${i}; then
 797                         rc=$((rc + 1))
 798                 fi
 799         done
 800         [[ $rc != 0 ]] && error "nodemap_modify with $rc" && return 2
 801
 802         rc=0
 803         delete_nodemaps
 804         rc=$?
 805         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 3
 806
 807         return 0
 808 }
 809 run_test 11 "nodemap modify"
 810
 811 test_12() {
 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 ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 0; then
 827                         rc=$((rc + 1))
 828                 fi
 829         done
 830         [[ $rc != 0 ]] && error "nodemap squash_uid with $rc" && return 2
 831
 832         rc=0
 833         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 834                 if ! squash_id ${HOSTNAME_CHECKSUM}_${i} 88 1; then
 835                         rc=$((rc + 1))
 836                 fi
 837         done
 838         [[ $rc != 0 ]] && error "nodemap squash_gid with $rc" && return 3
 839
 840         rc=0
 841         delete_nodemaps
 842         rc=$?
 843         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 844
 845         return 0
 846 }
 847 run_test 12 "nodemap set squash ids"
 848
 849 test_13() {
 850         local rc
 851
 852         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 853         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 854                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 855                 return
 856
 857         rc=0
 858         create_nodemaps
 859         rc=$?
 860         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 861
 862         rc=0
 863         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 864                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 865                         rc=$((rc + 1))
 866                 fi
 867         done
 868         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 869
 870         rc=0
 871         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 872                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 873                         for k in $NODEMAP_IPADDR_LIST; do
 874                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
 875                                        ${HOSTNAME_CHECKSUM}_${i}; then
 876                                         rc=$((rc + 1))
 877                                 fi
 878                         done
 879                 done
 880         done
 881         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
 882
 883         rc=0
 884         delete_nodemaps
 885         rc=$?
 886         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 887
 888         return 0
 889 }
 890 run_test 13 "test nids"
 891
 892 test_14() {
 893         local rc
 894
 895         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 896         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 897                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 898                 return
 899
 900         rc=0
 901         create_nodemaps
 902         rc=$?
 903         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 904
 905         rc=0
 906         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 907                 for ((j = 0; j < NODEMAP_RANGE_COUNT; j++)); do
 908                         for k in $NODEMAP_IPADDR_LIST; do
 909                                 if ! test_nid $SUBNET_CHECKSUM.$i.$j.$k \
 910                                         default; then
 911                                         rc=$((rc + 1))
 912                                 fi
 913                         done
 914                 done
 915         done
 916         [[ $rc != 0 ]] && error "nodemap_test_nid failed with $rc" && return 3
 917
 918         rc=0
 919         delete_nodemaps
 920         rc=$?
 921         [[ $rc != 0 ]] && error "nodemap_del failed with $rc" && return 4
 922
 923         return 0
 924 }
 925 run_test 14 "test default nodemap nid lookup"
 926
 927 test_15() {
 928         local rc
 929
 930         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
 931         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
 932                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
 933                 return
 934
 935         rc=0
 936         create_nodemaps
 937         rc=$?
 938         [[ $rc != 0 ]] && error "nodemap_add failed with $rc" && return 1
 939
 940         rc=0
 941         for ((i = 0; i < NODEMAP_COUNT; i++)); do
 942                 if ! add_range ${HOSTNAME_CHECKSUM}_${i} $i; then
 943                         rc=$((rc + 1))
 944                 fi
 945         done
 946         [[ $rc != 0 ]] && error "nodemap_add_range failed with $rc" && return 2
 947
 948         rc=0
 949         add_idmaps
 950         rc=$?
 951         [[ $rc != 0 ]] && error "nodemap_add_idmap failed with $rc" && return 3
 952
 953         rc=0
 954         test_idmap
 955         rc=$?
 956         [[ $rc != 0 ]] && error "nodemap_test_id failed with $rc" && return 4
 957
 958         rc=0
 959         update_idmaps
 960         rc=$?
 961         [[ $rc != 0 ]] && error "update_idmaps failed with $rc" && return 5
 962
 963         rc=0
 964         delete_idmaps
 965         rc=$?
 966         [[ $rc != 0 ]] && error "nodemap_del_idmap failed with $rc" && return 6
 967
 968         rc=0
 969         delete_nodemaps
 970         rc=$?
 971         [[ $rc != 0 ]] && error "nodemap_delete failed with $rc" && return 7
 972
 973         return 0
 974 }
 975 run_test 15 "test id mapping"
 976
 977 wait_nm_sync() {
 978         local nodemap_name=$1
 979         local key=$2
 980         local value=$3
 981         local proc_param="${nodemap_name}.${key}"
 982         [ "$nodemap_name" == "active" ] && proc_param="active"
 983
 984         local is_active=$(do_facet mgs $LCTL get_param -n nodemap.active)
 985         (( is_active == 0 )) && [ "$proc_param" != "active" ] && return
 986
 987         local max_retries=20
 988         local is_sync
 989         local out1=""
 990         local out2
 991         local mgs_ip=$(host_nids_address $mgs_HOST $NETTYPE | cut -d' ' -f1)
 992         local i
 993
 994         if [ -z "$value" ]; then
 995                 out1=$(do_facet mgs $LCTL get_param nodemap.${proc_param})
 996                 echo "On MGS ${mgs_ip}, ${proc_param} = $out1"
 997         else
 998                 out1=$value;
 999         fi
1000
1001         # wait up to 10 seconds for other servers to sync with mgs
1002         for i in $(seq 1 10); do
1003                 for node in $(all_server_nodes); do
1004                     local node_ip=$(host_nids_address $node $NETTYPE |
1005                                     cut -d' ' -f1)
1006
1007                     is_sync=true
1008                     if [ -z "$value" ]; then
1009                         [ $node_ip == $mgs_ip ] && continue
1010                     fi
1011
1012                     out2=$(do_node $node_ip $LCTL get_param \
1013                                    nodemap.$proc_param 2>/dev/null)
1014                     echo "On $node ${node_ip}, ${proc_param} = $out2"
1015                     [ "$out1" != "$out2" ] && is_sync=false && break
1016                 done
1017                 $is_sync && break
1018                 sleep 1
1019         done
1020         if ! $is_sync; then
1021                 echo MGS
1022                 echo $out1
1023                 echo OTHER - IP: $node_ip
1024                 echo $out2
1025                 error "mgs and $nodemap_name ${key} mismatch, $i attempts"
1026         fi
1027         echo "waited $((i - 1)) seconds for sync"
1028 }
1029
1030 create_fops_nodemaps() {
1031         local i=0
1032         local client
1033         for client in $clients; do
1034                 local client_ip=$(host_nids_address $client $NETTYPE)
1035                 local client_nid=$(h2nettype $client_ip)
1036                 do_facet mgs $LCTL nodemap_add c${i} || return 1
1037                 do_facet mgs $LCTL nodemap_add_range    \
1038                         --name c${i} --range $client_nid || return 1
1039                 for map in ${FOPS_IDMAPS[i]}; do
1040                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
1041                                 --idtype uid --idmap ${map} || return 1
1042                         do_facet mgs $LCTL nodemap_add_idmap --name c${i} \
1043                                 --idtype gid --idmap ${map} || return 1
1044                 done
1045
1046                 wait_nm_sync c$i idmap
1047
1048                 i=$((i + 1))
1049         done
1050         return 0
1051 }
1052
1053 delete_fops_nodemaps() {
1054         local i=0
1055         local client
1056         for client in $clients; do
1057                 do_facet mgs $LCTL nodemap_del c${i} || return 1
1058                 i=$((i + 1))
1059         done
1060         return 0
1061 }
1062
1063 fops_mds_index=0
1064 nm_test_mkdir() {
1065         if [ $MDSCOUNT -le 1 ]; then
1066                 do_node ${clients_arr[0]} mkdir -p $DIR/$tdir
1067         else
1068                 # round-robin MDTs to test DNE nodemap support
1069                 [ ! -d $DIR ] && do_node ${clients_arr[0]} mkdir -p $DIR
1070                 do_node ${clients_arr[0]} $LFS setdirstripe -c 1 -i \
1071                         $((fops_mds_index % MDSCOUNT)) $DIR/$tdir
1072                 ((fops_mds_index++))
1073         fi
1074 }
1075
1076 # acl test directory needs to be initialized on a privileged client
1077 fops_test_setup() {
1078         local admin=$(do_facet mgs $LCTL get_param -n nodemap.c0.admin_nodemap)
1079         local trust=$(do_facet mgs $LCTL get_param -n \
1080                 nodemap.c0.trusted_nodemap)
1081
1082         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1083         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1084
1085         wait_nm_sync c0 admin_nodemap
1086         wait_nm_sync c0 trusted_nodemap
1087
1088         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1089         nm_test_mkdir
1090         do_node ${clients_arr[0]} chown $user $DIR/$tdir
1091
1092         do_facet mgs $LCTL nodemap_modify --name c0 \
1093                 --property admin --value $admin
1094         do_facet mgs $LCTL nodemap_modify --name c0 \
1095                 --property trusted --value $trust
1096
1097         # flush MDT locks to make sure they are reacquired before test
1098         do_node ${clients_arr[0]} $LCTL set_param \
1099                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1100
1101         wait_nm_sync c0 admin_nodemap
1102         wait_nm_sync c0 trusted_nodemap
1103 }
1104
1105 # fileset test directory needs to be initialized on a privileged client
1106 fileset_test_setup() {
1107         local nm=$1
1108         local admin=$(do_facet mgs $LCTL get_param -n \
1109                 nodemap.${nm}.admin_nodemap)
1110         local trust=$(do_facet mgs $LCTL get_param -n \
1111                 nodemap.${nm}.trusted_nodemap)
1112
1113         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1114         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1115                 --value 1
1116
1117         wait_nm_sync $nm admin_nodemap
1118         wait_nm_sync $nm trusted_nodemap
1119
1120         # create directory and populate it for subdir mount
1121         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir ||
1122                 error "unable to create dir $MOUNT/$subdir"
1123         do_node ${clients_arr[0]} touch $MOUNT/$subdir/this_is_$subdir ||
1124                 error "unable to create file $MOUNT/$subdir/this_is_$subdir"
1125         do_node ${clients_arr[0]} mkdir $MOUNT/$subdir/$subsubdir ||
1126                 error "unable to create dir $MOUNT/$subdir/$subsubdir"
1127         do_node ${clients_arr[0]} touch \
1128                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir ||
1129                 error "unable to create file \
1130                         $MOUNT/$subdir/$subsubdir/this_is_$subsubdir"
1131
1132         do_facet mgs $LCTL nodemap_modify --name $nm \
1133                 --property admin --value $admin
1134         do_facet mgs $LCTL nodemap_modify --name $nm \
1135                 --property trusted --value $trust
1136
1137         # flush MDT locks to make sure they are reacquired before test
1138         do_node ${clients_arr[0]} $LCTL set_param \
1139                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1140
1141         wait_nm_sync $nm admin_nodemap
1142         wait_nm_sync $nm trusted_nodemap
1143 }
1144
1145 # fileset test directory needs to be initialized on a privileged client
1146 fileset_test_cleanup() {
1147         local nm=$1
1148         local admin=$(do_facet mgs $LCTL get_param -n \
1149                 nodemap.${nm}.admin_nodemap)
1150         local trust=$(do_facet mgs $LCTL get_param -n \
1151                 nodemap.${nm}.trusted_nodemap)
1152
1153         do_facet mgs $LCTL nodemap_modify --name $nm --property admin --value 1
1154         do_facet mgs $LCTL nodemap_modify --name $nm --property trusted \
1155                 --value 1
1156
1157         wait_nm_sync $nm admin_nodemap
1158         wait_nm_sync $nm trusted_nodemap
1159
1160         # cleanup directory created for subdir mount
1161         do_node ${clients_arr[0]} rm -rf $MOUNT/$subdir ||
1162                 error "unable to remove dir $MOUNT/$subdir"
1163
1164         do_facet mgs $LCTL nodemap_modify --name $nm \
1165                 --property admin --value $admin
1166         do_facet mgs $LCTL nodemap_modify --name $nm \
1167                 --property trusted --value $trust
1168
1169         # flush MDT locks to make sure they are reacquired before test
1170         do_node ${clients_arr[0]} $LCTL set_param \
1171                 ldlm.namespaces.$FSNAME-MDT*.lru_size=clear
1172
1173         wait_nm_sync $nm admin_nodemap
1174         wait_nm_sync $nm trusted_nodemap
1175 }
1176
1177 do_create_delete() {
1178         local run_u=$1
1179         local key=$2
1180         local testfile=$DIR/$tdir/$tfile
1181         local rc=0
1182         local c=0 d=0
1183         local qused_new
1184         if $run_u touch $testfile >& /dev/null; then
1185                 c=1
1186                 $run_u rm $testfile && d=1
1187         fi >& /dev/null
1188
1189         local res="$c $d"
1190         local expected=$(get_cr_del_expected $key)
1191         [ "$res" != "$expected" ] &&
1192                 error "test $key, wanted $expected, got $res" && rc=$((rc + 1))
1193         return $rc
1194 }
1195
1196 nodemap_check_quota() {
1197         local run_u="$1"
1198         $run_u lfs quota -q $DIR | awk '{ print $2; exit; }'
1199 }
1200
1201 do_fops_quota_test() {
1202         local run_u=$1
1203         # fuzz quota used to account for possible indirect blocks, etc
1204         local quota_fuzz=$(fs_log_size)
1205         local qused_orig=$(nodemap_check_quota "$run_u")
1206         local qused_high=$((qused_orig + quota_fuzz))
1207         local qused_low=$((qused_orig - quota_fuzz))
1208         local testfile=$DIR/$tdir/$tfile
1209         $run_u dd if=/dev/zero of=$testfile oflag=sync bs=1M count=1 \
1210                 >& /dev/null || error "unable to write quota test file"
1211         sync; sync_all_data || true
1212
1213         local qused_new=$(nodemap_check_quota "$run_u")
1214         [ $((qused_new)) -lt $((qused_low + 1024)) -o \
1215           $((qused_new)) -gt $((qused_high + 1024)) ] &&
1216                 error "$qused_new != $qused_orig + 1M after write, " \
1217                       "fuzz is $quota_fuzz"
1218         $run_u rm $testfile || error "unable to remove quota test file"
1219         wait_delete_completed_mds
1220
1221         qused_new=$(nodemap_check_quota "$run_u")
1222         [ $((qused_new)) -lt $((qused_low)) \
1223                 -o $((qused_new)) -gt $((qused_high)) ] &&
1224                 error "quota not reclaimed, expect $qused_orig, " \
1225                       "got $qused_new, fuzz $quota_fuzz"
1226 }
1227
1228 get_fops_mapped_user() {
1229         local cli_user=$1
1230
1231         for ((i=0; i < ${#FOPS_IDMAPS[@]}; i++)); do
1232                 for map in ${FOPS_IDMAPS[i]}; do
1233                         if [ $(cut -d: -f1 <<< "$map") == $cli_user ]; then
1234                                 cut -d: -f2 <<< "$map"
1235                                 return
1236                         fi
1237                 done
1238         done
1239         echo -1
1240 }
1241
1242 get_cr_del_expected() {
1243         local -a key
1244         IFS=":" read -a key <<< "$1"
1245         local mapmode="${key[0]}"
1246         local mds_user="${key[1]}"
1247         local cluster="${key[2]}"
1248         local cli_user="${key[3]}"
1249         local mode="0${key[4]}"
1250         local SUCCESS="1 1"
1251         local FAILURE="0 0"
1252         local noadmin=0
1253         local mapped=0
1254         local other=0
1255
1256         [[ $mapmode == *mapped* ]] && mapped=1
1257         # only c1 is mapped in these test cases
1258         [[ $mapmode == mapped_trusted* ]] && [ "$cluster" == "c0" ] && mapped=0
1259         [[ $mapmode == *noadmin* ]] && noadmin=1
1260
1261         # o+wx works as long as the user isn't mapped
1262         if [ $((mode & 3)) -eq 3 ]; then
1263                 other=1
1264         fi
1265
1266         # if client user is root, check if root is squashed
1267         if [ "$cli_user" == "0" ]; then
1268                 # squash root succeed, if other bit is on
1269                 case $noadmin in
1270                         0) echo $SUCCESS;;
1271                         1) [ "$other" == "1" ] && echo $SUCCESS
1272                            [ "$other" == "0" ] && echo $FAILURE;;
1273                 esac
1274                 return
1275         fi
1276         if [ "$mapped" == "0" ]; then
1277                 [ "$other" == "1" ] && echo $SUCCESS
1278                 [ "$other" == "0" ] && echo $FAILURE
1279                 return
1280         fi
1281
1282         # if mapped user is mds user, check for u+wx
1283         mapped_user=$(get_fops_mapped_user $cli_user)
1284         [ "$mapped_user" == "-1" ] &&
1285                 error "unable to find mapping for client user $cli_user"
1286
1287         if [ "$mapped_user" == "$mds_user" -a \
1288              $(((mode & 0300) == 0300)) -eq 1 ]; then
1289                 echo $SUCCESS
1290                 return
1291         fi
1292         if [ "$mapped_user" != "$mds_user" -a "$other" == "1" ]; then
1293                 echo $SUCCESS
1294                 return
1295         fi
1296         echo $FAILURE
1297 }
1298
1299 test_fops_admin_cli_i=""
1300 test_fops_chmod_dir() {
1301         local current_cli_i=$1
1302         local perm_bits=$2
1303         local dir_to_chmod=$3
1304         local new_admin_cli_i=""
1305
1306         # do we need to set up a new admin client?
1307         [ "$current_cli_i" == "0" ] && [ "$test_fops_admin_cli_i" != "1" ] &&
1308                 new_admin_cli_i=1
1309         [ "$current_cli_i" != "0" ] && [ "$test_fops_admin_cli_i" != "0" ] &&
1310                 new_admin_cli_i=0
1311
1312         # if only one client, and non-admin, need to flip admin everytime
1313         if [ "$num_clients" == "1" ]; then
1314                 test_fops_admin_client=$clients
1315                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1316                         nodemap.c0.admin_nodemap)
1317                 if [ "$test_fops_admin_val" != "1" ]; then
1318                         do_facet mgs $LCTL nodemap_modify \
1319                                 --name c0 \
1320                                 --property admin \
1321                                 --value 1
1322                         wait_nm_sync c0 admin_nodemap
1323                 fi
1324         elif [ "$new_admin_cli_i" != "" ]; then
1325                 # restore admin val to old admin client
1326                 if [ "$test_fops_admin_cli_i" != "" ] &&
1327                                 [ "$test_fops_admin_val" != "1" ]; then
1328                         do_facet mgs $LCTL nodemap_modify \
1329                                 --name c${test_fops_admin_cli_i} \
1330                                 --property admin \
1331                                 --value $test_fops_admin_val
1332                         wait_nm_sync c${test_fops_admin_cli_i} admin_nodemap
1333                 fi
1334
1335                 test_fops_admin_cli_i=$new_admin_cli_i
1336                 test_fops_admin_client=${clients_arr[$new_admin_cli_i]}
1337                 test_fops_admin_val=$(do_facet mgs $LCTL get_param -n \
1338                         nodemap.c${new_admin_cli_i}.admin_nodemap)
1339
1340                 if [ "$test_fops_admin_val" != "1" ]; then
1341                         do_facet mgs $LCTL nodemap_modify \
1342                                 --name c${new_admin_cli_i} \
1343                                 --property admin \
1344                                 --value 1
1345                         wait_nm_sync c${new_admin_cli_i} admin_nodemap
1346                 fi
1347         fi
1348
1349         do_node $test_fops_admin_client chmod $perm_bits $DIR/$tdir || return 1
1350
1351         # remove admin for single client if originally non-admin
1352         if [ "$num_clients" == "1" ] && [ "$test_fops_admin_val" != "1" ]; then
1353                 do_facet mgs $LCTL nodemap_modify --name c0 --property admin \
1354                         --value 0
1355                 wait_nm_sync c0 admin_nodemap
1356         fi
1357
1358         return 0
1359 }
1360
1361 test_fops() {
1362         local mapmode="$1"
1363         local single_client="$2"
1364         local client_user_list=([0]="0 $((IDBASE+3)) $((IDBASE+4))"
1365                                 [1]="0 $((IDBASE+5)) $((IDBASE+6))")
1366         local mds_i
1367         local rc=0
1368         local perm_bit_list="0 3 $((0300)) $((0303))"
1369         # SLOW tests 000-007, 010-070, 100-700 (octal modes)
1370         [ "$SLOW" == "yes" ] &&
1371                 perm_bit_list="0 $(seq 1 7) $(seq 8 8 63) $(seq 64 64 511) \
1372                                $((0303))"
1373
1374         # step through mds users. -1 means root
1375         for mds_i in -1 0 1 2; do
1376                 local user=$((mds_i + IDBASE))
1377                 local client
1378                 local x
1379
1380                 [ "$mds_i" == "-1" ] && user=0
1381
1382                 echo mkdir -p $DIR/$tdir
1383                 fops_test_setup
1384                 local cli_i=0
1385                 for client in $clients; do
1386                         local u
1387                         for u in ${client_user_list[$cli_i]}; do
1388                                 local run_u="do_node $client \
1389                                              $RUNAS_CMD -u$u -g$u -G$u"
1390                                 for perm_bits in $perm_bit_list; do
1391                                         local mode=$(printf %03o $perm_bits)
1392                                         local key
1393                                         key="$mapmode:$user:c$cli_i:$u:$mode"
1394                                         test_fops_chmod_dir $cli_i $mode \
1395                                                 $DIR/$tdir ||
1396                                                         error cannot chmod $key
1397                                         do_create_delete "$run_u" "$key"
1398                                 done
1399
1400                                 # check quota
1401                                 test_fops_chmod_dir $cli_i 777 $DIR/$tdir ||
1402                                         error cannot chmod $key
1403                                 do_fops_quota_test "$run_u"
1404                         done
1405
1406                         cli_i=$((cli_i + 1))
1407                         [ "$single_client" == "1" ] && break
1408                 done
1409                 rm -rf $DIR/$tdir
1410         done
1411         return $rc
1412 }
1413
1414 nodemap_version_check () {
1415         remote_mgs_nodsh && skip "remote MGS with nodsh" && return 1
1416         [ $(lustre_version_code mgs) -lt $(version_code 2.5.53) ] &&
1417                 skip "No nodemap on $(lustre_build_version mgs) MGS < 2.5.53" &&
1418                 return 1
1419         return 0
1420 }
1421
1422 nodemap_test_setup() {
1423         local rc
1424         local active_nodemap=1
1425
1426         [ "$1" == "0" ] && active_nodemap=0
1427
1428         do_nodes $(comma_list $(all_mdts_nodes)) \
1429                 $LCTL set_param mdt.*.identity_upcall=NONE
1430
1431         rc=0
1432         create_fops_nodemaps
1433         rc=$?
1434         [[ $rc != 0 ]] && error "adding fops nodemaps failed $rc"
1435
1436         do_facet mgs $LCTL nodemap_activate $active_nodemap
1437         wait_nm_sync active
1438
1439         do_facet mgs $LCTL nodemap_modify --name default \
1440                 --property admin --value 1
1441         do_facet mgs $LCTL nodemap_modify --name default \
1442                 --property trusted --value 1
1443         wait_nm_sync default trusted_nodemap
1444 }
1445
1446 nodemap_test_cleanup() {
1447         trap 0
1448         delete_fops_nodemaps
1449         rc=$?
1450         [[ $rc != 0 ]] && error "removing fops nodemaps failed $rc"
1451
1452         do_facet mgs $LCTL nodemap_modify --name default \
1453                  --property admin --value 0
1454         do_facet mgs $LCTL nodemap_modify --name default \
1455                  --property trusted --value 0
1456         wait_nm_sync default trusted_nodemap
1457
1458         do_facet mgs $LCTL nodemap_activate 0
1459         wait_nm_sync active 0
1460
1461         export SK_UNIQUE_NM=false
1462         return 0
1463 }
1464
1465 nodemap_clients_admin_trusted() {
1466         local admin=$1
1467         local tr=$2
1468         local i=0
1469         for client in $clients; do
1470                 do_facet mgs $LCTL nodemap_modify --name c0 \
1471                         --property admin --value $admin
1472                 do_facet mgs $LCTL nodemap_modify --name c0 \
1473                         --property trusted --value $tr
1474                 i=$((i + 1))
1475         done
1476         wait_nm_sync c$((i - 1)) admin_nodemap
1477         wait_nm_sync c$((i - 1)) trusted_nodemap
1478 }
1479
1480 test_16() {
1481         nodemap_version_check || return 0
1482         nodemap_test_setup 0
1483
1484         trap nodemap_test_cleanup EXIT
1485         test_fops all_off
1486         nodemap_test_cleanup
1487 }
1488 run_test 16 "test nodemap all_off fileops"
1489
1490 test_17() {
1491         nodemap_version_check || return 0
1492         nodemap_test_setup
1493
1494         trap nodemap_test_cleanup EXIT
1495         nodemap_clients_admin_trusted 0 1
1496         test_fops trusted_noadmin 1
1497         nodemap_test_cleanup
1498 }
1499 run_test 17 "test nodemap trusted_noadmin fileops"
1500
1501 test_18() {
1502         nodemap_version_check || return 0
1503         nodemap_test_setup
1504
1505         trap nodemap_test_cleanup EXIT
1506         nodemap_clients_admin_trusted 0 0
1507         test_fops mapped_noadmin 1
1508         nodemap_test_cleanup
1509 }
1510 run_test 18 "test nodemap mapped_noadmin fileops"
1511
1512 test_19() {
1513         nodemap_version_check || return 0
1514         nodemap_test_setup
1515
1516         trap nodemap_test_cleanup EXIT
1517         nodemap_clients_admin_trusted 1 1
1518         test_fops trusted_admin 1
1519         nodemap_test_cleanup
1520 }
1521 run_test 19 "test nodemap trusted_admin fileops"
1522
1523 test_20() {
1524         nodemap_version_check || return 0
1525         nodemap_test_setup
1526
1527         trap nodemap_test_cleanup EXIT
1528         nodemap_clients_admin_trusted 1 0
1529         test_fops mapped_admin 1
1530         nodemap_test_cleanup
1531 }
1532 run_test 20 "test nodemap mapped_admin fileops"
1533
1534 test_21() {
1535         nodemap_version_check || return 0
1536         nodemap_test_setup
1537
1538         trap nodemap_test_cleanup EXIT
1539         local x=1
1540         local i=0
1541         for client in $clients; do
1542                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1543                         --property admin --value 0
1544                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1545                         --property trusted --value $x
1546                 x=0
1547                 i=$((i + 1))
1548         done
1549         wait_nm_sync c$((i - 1)) trusted_nodemap
1550
1551         test_fops mapped_trusted_noadmin
1552         nodemap_test_cleanup
1553 }
1554 run_test 21 "test nodemap mapped_trusted_noadmin fileops"
1555
1556 test_22() {
1557         nodemap_version_check || return 0
1558         nodemap_test_setup
1559
1560         trap nodemap_test_cleanup EXIT
1561         local x=1
1562         local i=0
1563         for client in $clients; do
1564                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1565                         --property admin --value 1
1566                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1567                         --property trusted --value $x
1568                 x=0
1569                 i=$((i + 1))
1570         done
1571         wait_nm_sync c$((i - 1)) trusted_nodemap
1572
1573         test_fops mapped_trusted_admin
1574         nodemap_test_cleanup
1575 }
1576 run_test 22 "test nodemap mapped_trusted_admin fileops"
1577
1578 # acl test directory needs to be initialized on a privileged client
1579 nodemap_acl_test_setup() {
1580         local admin=$(do_facet mgs $LCTL get_param -n \
1581                       nodemap.c0.admin_nodemap)
1582         local trust=$(do_facet mgs $LCTL get_param -n \
1583                       nodemap.c0.trusted_nodemap)
1584
1585         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1586         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1587
1588         wait_nm_sync c0 admin_nodemap
1589         wait_nm_sync c0 trusted_nodemap
1590
1591         do_node ${clients_arr[0]} rm -rf $DIR/$tdir
1592         nm_test_mkdir
1593         do_node ${clients_arr[0]} chmod a+rwx $DIR/$tdir ||
1594                 error unable to chmod a+rwx test dir $DIR/$tdir
1595
1596         do_facet mgs $LCTL nodemap_modify --name c0 \
1597                 --property admin --value $admin
1598         do_facet mgs $LCTL nodemap_modify --name c0 \
1599                 --property trusted --value $trust
1600
1601         wait_nm_sync c0 trusted_nodemap
1602 }
1603
1604 # returns 0 if the number of ACLs does not change on the second (mapped) client
1605 # after being set on the first client
1606 nodemap_acl_test() {
1607         local user="$1"
1608         local set_client="$2"
1609         local get_client="$3"
1610         local check_setfacl="$4"
1611         local setfacl_error=0
1612         local testfile=$DIR/$tdir/$tfile
1613         local RUNAS_USER="$RUNAS_CMD -u $user"
1614         local acl_count=0
1615         local acl_count_post=0
1616
1617         nodemap_acl_test_setup
1618         sleep 5
1619
1620         do_node $set_client $RUNAS_USER touch $testfile
1621
1622         # ACL masks aren't filtered by nodemap code, so we ignore them
1623         acl_count=$(do_node $get_client getfacl $testfile | grep -v mask |
1624                 wc -l)
1625         do_node $set_client $RUNAS_USER setfacl -m $user:rwx $testfile ||
1626                 setfacl_error=1
1627
1628         # if check setfacl is set to 1, then it's supposed to error
1629         if [ "$check_setfacl" == "1" ]; then
1630                 [ "$setfacl_error" != "1" ] && return 1
1631                 return 0
1632         fi
1633         [ "$setfacl_error" == "1" ] && echo "WARNING: unable to setfacl"
1634
1635         acl_count_post=$(do_node $get_client getfacl $testfile | grep -v mask |
1636                 wc -l)
1637         [ $acl_count -eq $acl_count_post ] && return 0
1638         return 1
1639 }
1640
1641 test_23a() {
1642         nodemap_version_check || return 0
1643         nodemap_test_setup
1644
1645         trap nodemap_test_cleanup EXIT
1646         # 1 trusted cluster, 1 mapped cluster
1647         local unmapped_fs=$((IDBASE+0))
1648         local unmapped_c1=$((IDBASE+5))
1649         local mapped_fs=$((IDBASE+2))
1650         local mapped_c0=$((IDBASE+4))
1651         local mapped_c1=$((IDBASE+6))
1652
1653         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1654         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 1
1655
1656         do_facet mgs $LCTL nodemap_modify --name c1 --property admin --value 0
1657         do_facet mgs $LCTL nodemap_modify --name c1 --property trusted --value 0
1658
1659         wait_nm_sync c1 trusted_nodemap
1660
1661         # setfacl on trusted cluster to unmapped user, verify it's not seen
1662         nodemap_acl_test $unmapped_fs ${clients_arr[0]} ${clients_arr[1]} ||
1663                 error "acl count (1)"
1664
1665         # setfacl on trusted cluster to mapped user, verify it's seen
1666         nodemap_acl_test $mapped_fs ${clients_arr[0]} ${clients_arr[1]} &&
1667                 error "acl count (2)"
1668
1669         # setfacl on mapped cluster to mapped user, verify it's seen
1670         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1671                 error "acl count (3)"
1672
1673         # setfacl on mapped cluster to unmapped user, verify error
1674         nodemap_acl_test $unmapped_fs ${clients_arr[1]} ${clients_arr[0]} 1 ||
1675                 error "acl count (4)"
1676
1677         # 2 mapped clusters
1678         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 0
1679         do_facet mgs $LCTL nodemap_modify --name c0 --property trusted --value 0
1680
1681         wait_nm_sync c0 trusted_nodemap
1682
1683         # setfacl to mapped user on c1, also mapped to c0, verify it's seen
1684         nodemap_acl_test $mapped_c1 ${clients_arr[1]} ${clients_arr[0]} &&
1685                 error "acl count (5)"
1686
1687         # setfacl to mapped user on c1, not mapped to c0, verify not seen
1688         nodemap_acl_test $unmapped_c1 ${clients_arr[1]} ${clients_arr[0]} ||
1689                 error "acl count (6)"
1690
1691         nodemap_test_cleanup
1692 }
1693 run_test 23a "test mapped regular ACLs"
1694
1695 test_23b() { #LU-9929
1696         remote_mgs_nodsh && skip "remote MGS with nodsh" && return
1697         [ $(lustre_version_code mgs) -lt $(version_code 2.10.53) ] &&
1698                 skip "Need MGS >= 2.10.53" && return
1699
1700         nodemap_test_setup
1701         trap nodemap_test_cleanup EXIT
1702
1703         local testdir=$DIR/$tdir
1704         local fs_id=$((IDBASE+10))
1705         local unmapped_id
1706         local mapped_id
1707         local fs_user
1708
1709         do_facet mgs $LCTL nodemap_modify --name c0 --property admin --value 1
1710         wait_nm_sync c0 admin_nodemap
1711
1712         # Add idmap $ID0:$fs_id (500:60010)
1713         do_facet mgs $LCTL nodemap_add_idmap --name c0 --idtype gid \
1714                 --idmap $ID0:$fs_id ||
1715                 error "add idmap $ID0:$fs_id to nodemap c0 failed"
1716
1717         # set/getfacl default acl on client0 (unmapped gid=500)
1718         rm -rf $testdir
1719         mkdir -p $testdir
1720         # Here, USER0=$(getent passwd | grep :$ID0:$ID0: | cut -d: -f1)
1721         setfacl -R -d -m group:$USER0:rwx $testdir ||
1722                 error "setfacl $testdir on ${clients_arr[0]} failed"
1723         unmapped_id=$(getfacl $testdir | grep -E "default:group:.*:rwx" |
1724                         awk -F: '{print $3}')
1725         [ "$unmapped_id" = "$USER0" ] ||
1726                 error "gid=$ID0 was not unmapped correctly on ${clients_arr[0]}"
1727
1728         # getfacl default acl on MGS (mapped gid=60010)
1729         zconf_mount $mgs_HOST $MOUNT
1730         do_rpc_nodes $mgs_HOST is_mounted $MOUNT ||
1731                 error "mount lustre on MGS failed"
1732         mapped_id=$(do_node $mgs_HOST getfacl $testdir |
1733                         grep -E "default:group:.*:rwx" | awk -F: '{print $3}')
1734         fs_user=$(do_facet mgs getent passwd |
1735                         grep :$fs_id:$fs_id: | cut -d: -f1)
1736         [ $mapped_id -eq $fs_id -o "$mapped_id" = "$fs_user" ] ||
1737                 error "Should return gid=$fs_id or $fs_user on MGS"
1738
1739         rm -rf $testdir
1740         do_facet mgs umount $MOUNT
1741         nodemap_test_cleanup
1742 }
1743 run_test 23b "test mapped default ACLs"
1744
1745 test_24() {
1746         nodemap_test_setup
1747
1748         trap nodemap_test_cleanup EXIT
1749         do_nodes $(comma_list $(all_server_nodes)) $LCTL get_param -R nodemap ||
1750                 error "proc readable file read failed"
1751
1752         nodemap_test_cleanup
1753 }
1754 run_test 24 "check nodemap proc files for LBUGs and Oopses"
1755
1756 test_25() {
1757         local tmpfile=$(mktemp)
1758         local tmpfile2=$(mktemp)
1759         local tmpfile3=$(mktemp)
1760         local tmpfile4=$(mktemp)
1761         local subdir=c0dir
1762         local client
1763
1764         nodemap_version_check || return 0
1765
1766         # stop clients for this test
1767         zconf_umount_clients $CLIENTS $MOUNT ||
1768             error "unable to umount clients $CLIENTS"
1769
1770         export SK_UNIQUE_NM=true
1771         nodemap_test_setup
1772
1773         # enable trusted/admin for setquota call in cleanup_and_setup_lustre()
1774         i=0
1775         for client in $clients; do
1776                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1777                         --property admin --value 1
1778                 do_facet mgs $LCTL nodemap_modify --name c${i} \
1779                         --property trusted --value 1
1780                 ((i++))
1781         done
1782         wait_nm_sync c$((i - 1)) trusted_nodemap
1783
1784         trap nodemap_test_cleanup EXIT
1785
1786         # create a new, empty nodemap, and add fileset info to it
1787         do_facet mgs $LCTL nodemap_add test25 ||
1788                 error "unable to create nodemap $testname"
1789         do_facet mgs $LCTL set_param -P nodemap.$testname.fileset=/$subdir ||
1790                 error "unable to add fileset info to nodemap test25"
1791
1792         wait_nm_sync test25 id
1793
1794         do_facet mgs $LCTL nodemap_info > $tmpfile
1795         do_facet mds $LCTL nodemap_info > $tmpfile2
1796
1797         if ! $SHARED_KEY; then
1798                 # will conflict with SK's nodemaps
1799                 cleanup_and_setup_lustre
1800         fi
1801         # stop clients for this test
1802         zconf_umount_clients $CLIENTS $MOUNT ||
1803             error "unable to umount clients $CLIENTS"
1804
1805         do_facet mgs $LCTL nodemap_info > $tmpfile3
1806         diff -q $tmpfile3 $tmpfile >& /dev/null ||
1807                 error "nodemap_info diff on MGS after remount"
1808
1809         do_facet mds $LCTL nodemap_info > $tmpfile4
1810         diff -q $tmpfile4 $tmpfile2 >& /dev/null ||
1811                 error "nodemap_info diff on MDS after remount"
1812
1813         # cleanup nodemap
1814         do_facet mgs $LCTL nodemap_del test25 ||
1815             error "cannot delete nodemap test25 from config"
1816         nodemap_test_cleanup
1817         # restart clients previously stopped
1818         zconf_mount_clients $CLIENTS $MOUNT ||
1819             error "unable to mount clients $CLIENTS"
1820
1821         rm -f $tmpfile $tmpfile2
1822         export SK_UNIQUE_NM=false
1823 }
1824 run_test 25 "test save and reload nodemap config"
1825
1826 test_26() {
1827         nodemap_version_check || return 0
1828
1829         local large_i=32000
1830
1831         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_add"
1832         wait_nm_sync c$large_i admin_nodemap
1833
1834         do_facet mgs "seq -f 'c%g' $large_i | xargs -n1 $LCTL nodemap_del"
1835         wait_nm_sync c$large_i admin_nodemap
1836 }
1837 run_test 26 "test transferring very large nodemap"
1838
1839 nodemap_exercise_fileset() {
1840         local nm="$1"
1841         local fileset_on_mgs=""
1842         local loop=0
1843
1844         # setup
1845         if [ "$nm" == "default" ]; then
1846                 do_facet mgs $LCTL nodemap_activate 1
1847                 wait_nm_sync active
1848         else
1849                 nodemap_test_setup
1850         fi
1851         if $SHARED_KEY; then
1852                 export SK_UNIQUE_NM=true
1853         else
1854                 # will conflict with SK's nodemaps
1855                 trap "fileset_test_cleanup $nm" EXIT
1856         fi
1857         fileset_test_setup "$nm"
1858
1859         # add fileset info to $nm nodemap
1860         do_facet mgs $LCTL set_param nodemap.${nm}.fileset=/$subdir ||
1861                 error "unable to add fileset info to $nm nodemap on MGS"
1862         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=/$subdir ||
1863                error "unable to add fileset info to $nm nodemap for servers"
1864         wait_nm_sync $nm fileset "nodemap.${nm}.fileset=/$subdir"
1865
1866         # re-mount client
1867         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1868                 error "unable to umount client ${clients_arr[0]}"
1869         # set some generic fileset to trigger SSK code
1870         export FILESET=/
1871         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1872                 error "unable to remount client ${clients_arr[0]}"
1873         unset FILESET
1874
1875         # test mount point content
1876         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subdir ||
1877                 error "fileset not taken into account"
1878
1879         # re-mount client with sub-subdir
1880         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1881                 error "unable to umount client ${clients_arr[0]}"
1882         export FILESET=/$subsubdir
1883         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1884                 error "unable to remount client ${clients_arr[0]}"
1885         unset FILESET
1886
1887         # test mount point content
1888         do_node ${clients_arr[0]} test -f $MOUNT/this_is_$subsubdir ||
1889                 error "subdir of fileset not taken into account"
1890
1891         # remove fileset info from nodemap
1892         do_facet mgs $LCTL nodemap_set_fileset --name $nm --fileset \'\' ||
1893                 error "unable to delete fileset info on $nm nodemap"
1894         wait_update_facet mgs "$LCTL get_param nodemap.${nm}.fileset" \
1895                           "nodemap.${nm}.fileset=" ||
1896                 error "fileset info still not cleared on $nm nodemap"
1897         do_facet mgs $LCTL set_param -P nodemap.${nm}.fileset=\'\' ||
1898                 error "unable to reset fileset info on $nm nodemap"
1899         wait_nm_sync $nm fileset "nodemap.${nm}.fileset="
1900
1901         # re-mount client
1902         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1903                 error "unable to umount client ${clients_arr[0]}"
1904         zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1905                 error "unable to remount client ${clients_arr[0]}"
1906
1907         # test mount point content
1908         if ! $(do_node ${clients_arr[0]} test -d $MOUNT/$subdir); then
1909                 ls $MOUNT
1910                 error "fileset not cleared on $nm nodemap"
1911         fi
1912
1913         # back to non-nodemap setup
1914         if $SHARED_KEY; then
1915                 export SK_UNIQUE_NM=false
1916                 zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1917                         error "unable to umount client ${clients_arr[0]}"
1918         fi
1919         fileset_test_cleanup "$nm"
1920         if [ "$nm" == "default" ]; then
1921                 do_facet mgs $LCTL nodemap_activate 0
1922                 wait_nm_sync active 0
1923                 trap 0
1924                 export SK_UNIQUE_NM=false
1925         else
1926                 nodemap_test_cleanup
1927         fi
1928         if $SHARED_KEY; then
1929                 zconf_mount_clients ${clients_arr[0]} $MOUNT $MOUNT_OPTS ||
1930                         error "unable to remount client ${clients_arr[0]}"
1931         fi
1932 }
1933
1934 test_27() {
1935         for nm in "default" "c0"; do
1936                 local subdir="subdir_${nm}"
1937                 local subsubdir="subsubdir_${nm}"
1938
1939                 echo "Exercising fileset for nodemap $nm"
1940                 nodemap_exercise_fileset "$nm"
1941         done
1942 }
1943 run_test 27 "test fileset in various nodemaps"
1944
1945 test_28() {
1946         if ! $SHARED_KEY; then
1947                 skip "need shared key feature for this test" && return
1948         fi
1949         mkdir -p $DIR/$tdir || error "mkdir failed"
1950         touch $DIR/$tdir/$tdir.out || error "touch failed"
1951         if [ ! -f $DIR/$tdir/$tdir.out ]; then
1952                 error "read before rotation failed"
1953         fi
1954         # store top key identity to ensure rotation has occurred
1955         SK_IDENTITY_OLD=$(lctl get_param *.*.*srpc* | grep "expire" |
1956                 head -1 | awk '{print $15}' | cut -c1-8)
1957         do_facet $SINGLEMDS lfs flushctx ||
1958                  error "could not run flushctx on $SINGLEMDS"
1959         sleep 5
1960         lfs flushctx || error "could not run flushctx on client"
1961         sleep 5
1962         # verify new key is in place
1963         SK_IDENTITY_NEW=$(lctl get_param *.*.*srpc* | grep "expire" |
1964                 head -1 | awk '{print $15}' | cut -c1-8)
1965         if [ $SK_IDENTITY_OLD == $SK_IDENTITY_NEW ]; then
1966                 error "key did not rotate correctly"
1967         fi
1968         if [ ! -f $DIR/$tdir/$tdir.out ]; then
1969                 error "read after rotation failed"
1970         fi
1971 }
1972 run_test 28 "check shared key rotation method"
1973
1974 test_29() {
1975         if ! $SHARED_KEY; then
1976                 skip "need shared key feature for this test" && return
1977         fi
1978         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
1979                 skip "test only valid if integrity is active"
1980         fi
1981         rm -r $DIR/$tdir
1982         mkdir $DIR/$tdir || error "mkdir"
1983         touch $DIR/$tdir/$tfile || error "touch"
1984         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
1985                 error "unable to umount clients"
1986         keyctl show | awk '/lustre/ { print $1 }' |
1987                 xargs -IX keyctl unlink X
1988         OLD_SK_PATH=$SK_PATH
1989         export SK_PATH=/dev/null
1990         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
1991                 export SK_PATH=$OLD_SK_PATH
1992                 if [ -e $DIR/$tdir/$tfile ]; then
1993                         error "able to mount and read without key"
1994                 else
1995                         error "able to mount without key"
1996                 fi
1997         else
1998                 export SK_PATH=$OLD_SK_PATH
1999                 keyctl show | awk '/lustre/ { print $1 }' |
2000                         xargs -IX keyctl unlink X
2001         fi
2002 }
2003 run_test 29 "check for missing shared key"
2004
2005 test_30() {
2006         if ! $SHARED_KEY; then
2007                 skip "need shared key feature for this test" && return
2008         fi
2009         if [ $SK_FLAVOR != "ski" ] && [ $SK_FLAVOR != "skpi" ]; then
2010                 skip "test only valid if integrity is active"
2011         fi
2012         mkdir -p $DIR/$tdir || error "mkdir failed"
2013         touch $DIR/$tdir/$tdir.out || error "touch failed"
2014         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2015                 error "unable to umount clients"
2016         # unload keys from ring
2017         keyctl show | awk '/lustre/ { print $1 }' |
2018                 xargs -IX keyctl unlink X
2019         # invalidate the key with bogus filesystem name
2020         lgss_sk -w $SK_PATH/$FSNAME-bogus.key -f $FSNAME.bogus \
2021                 -t client -d /dev/urandom || error "lgss_sk failed (1)"
2022         do_facet $SINGLEMDS lfs flushctx || error "could not run flushctx"
2023         OLD_SK_PATH=$SK_PATH
2024         export SK_PATH=$SK_PATH/$FSNAME-bogus.key
2025         if zconf_mount_clients ${clients_arr[0]} $MOUNT; then
2026                 SK_PATH=$OLD_SK_PATH
2027                 if [ -a $DIR/$tdir/$tdir.out ]; then
2028                         error "mount and read file with invalid key"
2029                 else
2030                         error "mount with invalid key"
2031                 fi
2032         fi
2033         SK_PATH=$OLD_SK_PATH
2034         zconf_umount_clients ${clients_arr[0]} $MOUNT ||
2035                 error "unable to umount clients"
2036 }
2037 run_test 30 "check for invalid shared key"
2038
2039 log "cleanup: ======================================================"
2040
2041 sec_unsetup() {
2042         ## nodemap deactivated
2043         do_facet mgs $LCTL nodemap_activate 0
2044
2045         for num in $(seq $MDSCOUNT); do
2046                 if [ "${identity_old[$num]}" = 1 ]; then
2047                         switch_identity $num false || identity_old[$num]=$?
2048                 fi
2049         done
2050
2051         $RUNAS_CMD -u $ID0 ls $DIR
2052         $RUNAS_CMD -u $ID1 ls $DIR
2053 }
2054 sec_unsetup
2055
2056 sec_cleanup
2057
2058 complete $SECONDS
2059 exit_status