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