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