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