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