Print this page
7290 ZFS test suite needs to control what utilities it can run
Reviewed by: Dan Kimmel <dan.kimmel@delphix.com>
Reviewed by: Matthew Ahrens <mahrens@delphix.com>
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/test/zfs-tests/tests/functional/delegate/delegate_common.kshlib
+++ new/usr/src/test/zfs-tests/tests/functional/delegate/delegate_common.kshlib
1 1 #
2 2 # CDDL HEADER START
3 3 #
4 4 # The contents of this file are subject to the terms of the
5 5 # Common Development and Distribution License (the "License").
6 6 # You may not use this file except in compliance with the License.
7 7 #
8 8 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 # or http://www.opensolaris.org/os/licensing.
10 10 # See the License for the specific language governing permissions
11 11 # and limitations under the License.
12 12 #
13 13 # When distributing Covered Code, include this CDDL HEADER in each
14 14 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 # If applicable, add the following below this CDDL HEADER, with the
16 16 # fields enclosed by brackets "[]" replaced with your own identifying
17 17 # information: Portions Copyright [yyyy] [name of copyright owner]
|
↓ open down ↓ |
17 lines elided |
↑ open up ↑ |
18 18 #
19 19 # CDDL HEADER END
20 20 #
21 21
22 22 #
23 23 # Copyright 2008 Sun Microsystems, Inc. All rights reserved.
24 24 # Use is subject to license terms.
25 25 #
26 26
27 27 #
28 -# Copyright (c) 2013 by Delphix. All rights reserved.
28 +# Copyright (c) 2013, 2016 by Delphix. All rights reserved.
29 29 # Copyright 2016 Nexenta Systems, Inc.
30 30 #
31 31
32 32 . $STF_SUITE/include/libtest.shlib
33 33 . $STF_SUITE/tests/functional/delegate/delegate.cfg
34 34
35 35 #
36 36 # Cleanup exist user/group.
37 37 #
38 38 function cleanup_user_group
39 39 {
40 40 typeset i
41 41 for i in $STAFF1 $STAFF2 $OTHER1 $OTHER2 ; do
42 42 del_user $i
43 43 done
44 44 for i in $STAFF_GROUP $OTHER_GROUP ; do
45 45 del_group $i
46 46 done
|
↓ open down ↓ |
8 lines elided |
↑ open up ↑ |
47 47
48 48 return 0
49 49 }
50 50
51 51 #
52 52 # Restore test file system to the original status.
53 53 #
54 54 function restore_root_datasets
55 55 {
56 56 if datasetexists $ROOT_TESTFS ; then
57 - log_must $ZFS destroy -Rf $ROOT_TESTFS
57 + log_must zfs destroy -Rf $ROOT_TESTFS
58 58 fi
59 - log_must $ZFS create $ROOT_TESTFS
59 + log_must zfs create $ROOT_TESTFS
60 60
61 61 if is_global_zone ; then
62 62 if datasetexists $ROOT_TESTVOL ; then
63 - log_must $ZFS destroy -Rf $ROOT_TESTVOL
63 + log_must zfs destroy -Rf $ROOT_TESTVOL
64 64 fi
65 - log_must $ZFS create -V $VOLSIZE $ROOT_TESTVOL
65 + log_must zfs create -V $VOLSIZE $ROOT_TESTVOL
66 66 fi
67 67
68 68 return 0
69 69 }
70 70
71 71 #
72 72 # Verify the specified user have permission on the dataset
73 73 #
74 74 # $1 dataset
75 75 # $2 permissions which are separated by comma(,)
76 76 # $3-n users
77 77 #
78 78 function verify_perm
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
79 79 {
80 80 typeset dtst=$1
81 81 typeset permissions=$2
82 82 shift 2
83 83
84 84 if [[ -z $@ || -z $permissions || -z $dtst ]]; then
85 85 return 1
86 86 fi
87 87
88 88 typeset type=$(get_prop type $dtst)
89 - permissions=$($ECHO $permissions | $TR -s "," " ")
89 + permissions=$(echo $permissions | tr -s "," " ")
90 90
91 91 typeset user
92 92 for user in $@; do
93 93 typeset perm
94 94 for perm in $permissions; do
95 95 typeset -i ret=1
96 96 if [[ $type == "filesystem" ]]; then
97 97 check_fs_perm $user $perm $dtst
98 98 ret=$?
99 99 elif [[ $type == "volume" ]]; then
100 100 check_vol_perm $user $perm $dtst
101 101 ret=$?
102 102 fi
103 103
104 104 if ((ret != 0)) ; then
105 105 log_note "Fail: $user should have $perm " \
106 106 "on $dtst"
107 107 return 1
108 108 fi
109 109 done
110 110 done
111 111
112 112 return 0
113 113 }
114 114
115 115 #
116 116 # Verify the specified user have no permission on the dataset
117 117 #
118 118 # $1 dataset
119 119 # $2 permissions which are separated by comma(,)
120 120 # $3-n users
121 121 #
122 122 function verify_noperm
|
↓ open down ↓ |
23 lines elided |
↑ open up ↑ |
123 123 {
124 124 typeset dtst=$1
125 125 typeset permissions=$2
126 126 shift 2
127 127
128 128 if [[ -z $@ || -z $permissions || -z $dtst ]]; then
129 129 return 1
130 130 fi
131 131
132 132 typeset type=$(get_prop type $dtst)
133 - permissions=$($ECHO $permissions | $TR -s "," " ")
133 + permissions=$(echo $permissions | tr -s "," " ")
134 134
135 135 typeset user
136 136 for user in $@; do
137 137 typeset perm
138 138 for perm in $permissions; do
139 139 typeset -i ret=1
140 140 if [[ $type == "filesystem" ]]; then
141 141 check_fs_perm $user $perm $dtst
142 142 ret=$?
143 143 elif [[ $type == "volume" ]]; then
144 144 check_vol_perm $user $perm $dtst
145 145 ret=$?
146 146 fi
147 147
148 148 if ((ret == 0)) ; then
149 149 log_note "Fail: $user should not have $perm " \
150 150 "on $dtst"
151 151 return 1
152 152 fi
153 153 done
154 154 done
155 155
156 156 return 0
157 157 }
158 158
159 159 function common_perm
160 160 {
161 161 typeset user=$1
162 162 typeset perm=$2
163 163 typeset dtst=$3
164 164
165 165 typeset -i ret=1
166 166 case $perm in
167 167 send)
168 168 verify_send $user $perm $dtst
169 169 ret=$?
170 170 ;;
171 171 allow)
172 172 verify_allow $user $perm $dtst
173 173 ret=$?
174 174 ;;
175 175 userprop)
176 176 verify_userprop $user $perm $dtst
177 177 ret=$?
178 178 ;;
179 179 compression|checksum|readonly)
180 180 verify_ccr $user $perm $dtst
181 181 ret=$?
182 182 ;;
183 183 copies)
184 184 verify_copies $user $perm $dtst
185 185 ret=$?
186 186 ;;
187 187 reservation)
188 188 verify_reservation $user $perm $dtst
189 189 ret=$?
190 190 ;;
191 191 *)
192 192 ret=1
193 193 ;;
194 194 esac
195 195
196 196 return $ret
197 197 }
198 198
199 199 function check_fs_perm
200 200 {
201 201 typeset user=$1
202 202 typeset perm=$2
203 203 typeset fs=$3
204 204
205 205 typeset -i ret=1
206 206 case $perm in
207 207 create)
208 208 verify_fs_create $user $perm $fs
209 209 ret=$?
210 210 ;;
211 211 destroy)
212 212 verify_fs_destroy $user $perm $fs
213 213 ret=$?
214 214 ;;
215 215 snapshot)
216 216 verify_fs_snapshot $user $perm $fs
217 217 ret=$?
218 218 ;;
219 219 rollback)
220 220 verify_fs_rollback $user $perm $fs
221 221 ret=$?
222 222 ;;
223 223 clone)
224 224 verify_fs_clone $user $perm $fs
225 225 ret=$?
226 226 ;;
227 227 rename)
228 228 verify_fs_rename $user $perm $fs
229 229 ret=$?
230 230 ;;
231 231 mount)
232 232 verify_fs_mount $user $perm $fs
233 233 ret=$?
234 234 ;;
235 235 share)
236 236 verify_fs_share $user $perm $fs
237 237 ret=$?
238 238 ;;
239 239 mountpoint)
240 240 verify_fs_mountpoint $user $perm $fs
241 241 ret=$?
242 242 ;;
243 243 promote)
244 244 verify_fs_promote $user $perm $fs
245 245 ret=$?
246 246 ;;
247 247 canmount)
248 248 verify_fs_canmount $user $perm $fs
249 249 ret=$?
250 250 ;;
251 251 recordsize)
252 252 verify_fs_recordsize $user $perm $fs
253 253 ret=$?
254 254 ;;
255 255 quota)
256 256 verify_fs_quota $user $perm $fs
257 257 ret=$?
258 258 ;;
259 259 aclmode)
260 260 verify_fs_aclmode $user $perm $fs
261 261 ret=$?
262 262 ;;
263 263 aclinherit)
264 264 verify_fs_aclinherit $user $perm $fs
265 265 ret=$?
266 266 ;;
267 267 snapdir)
268 268 verify_fs_snapdir $user $perm $fs
269 269 ret=$?
270 270 ;;
271 271 atime|exec|devices|setuid|xattr)
272 272 verify_fs_aedsx $user $perm $fs
273 273 ret=$?
274 274 ;;
275 275 zoned)
276 276 verify_fs_zoned $user $perm $fs
277 277 ret=$?
278 278 ;;
279 279 sharenfs)
280 280 verify_fs_sharenfs $user $perm $fs
281 281 ret=$?
282 282 ;;
283 283 receive)
284 284 verify_fs_receive $user $perm $fs
285 285 ret=$?
286 286 ;;
287 287 *)
288 288 common_perm $user $perm $fs
289 289 ret=$?
290 290 ;;
291 291 esac
292 292
293 293 return $ret
294 294 }
295 295
296 296 function check_vol_perm
297 297 {
298 298 typeset user=$1
299 299 typeset perm=$2
300 300 typeset vol=$3
301 301
302 302 typeset -i ret=1
303 303 case $perm in
304 304 destroy)
305 305 verify_vol_destroy $user $perm $vol
306 306 ret=$?
307 307 ;;
308 308 snapshot)
309 309 verify_vol_snapshot $user $perm $vol
310 310 ret=$?
311 311 ;;
312 312 rollback)
313 313 verify_vol_rollback $user $perm $vol
314 314 ret=$?
315 315 ;;
316 316 clone)
317 317 verify_vol_clone $user $perm $vol
318 318 ret=$?
319 319 ;;
320 320 rename)
321 321 verify_vol_rename $user $perm $vol
322 322 ret=$?
323 323 ;;
324 324 promote)
325 325 verify_vol_promote $user $perm $vol
326 326 ret=$?
327 327 ;;
328 328 volsize)
329 329 verify_vol_volsize $user $perm $vol
330 330 ret=$?
331 331 ;;
332 332 *)
333 333 common_perm $user $perm $vol
334 334 ret=$?
|
↓ open down ↓ |
191 lines elided |
↑ open up ↑ |
335 335 ;;
336 336 esac
337 337
338 338 return $ret
339 339 }
340 340
341 341 function setup_unallow_testenv
342 342 {
343 343 log_must restore_root_datasets
344 344
345 - log_must $ZFS create $SUBFS
345 + log_must zfs create $SUBFS
346 346
347 347 for dtst in $DATASETS ; do
348 - log_must $ZFS allow -l $STAFF1 $LOCAL_SET $dtst
349 - log_must $ZFS allow -d $STAFF2 $DESC_SET $dtst
350 - log_must $ZFS allow $OTHER1 $LOCAL_DESC_SET $dtst
351 - log_must $ZFS allow $OTHER2 $LOCAL_DESC_SET $dtst
348 + log_must zfs allow -l $STAFF1 $LOCAL_SET $dtst
349 + log_must zfs allow -d $STAFF2 $DESC_SET $dtst
350 + log_must zfs allow $OTHER1 $LOCAL_DESC_SET $dtst
351 + log_must zfs allow $OTHER2 $LOCAL_DESC_SET $dtst
352 352
353 353 log_must verify_perm $dtst $LOCAL_SET $STAFF1
354 354 log_must verify_perm $dtst $LOCAL_DESC_SET $OTHER1
355 355 log_must verify_perm $dtst $LOCAL_DESC_SET $OTHER2
356 356 if [[ $dtst == $ROOT_TESTFS ]]; then
357 357 log_must verify_perm $SUBFS $DESC_SET $STAFF2
358 358 log_must verify_perm $SUBFS $LOCAL_DESC_SET $OTHER1
359 359 log_must verify_perm $SUBFS $LOCAL_DESC_SET $OTHER2
360 360 fi
361 361 done
362 362
363 363 return 0
364 364 }
365 365
366 366 #
367 367 # Verify permission send for specified user on the dataset
368 368 # $1 user
|
↓ open down ↓ |
7 lines elided |
↑ open up ↑ |
369 369 # $2 permission
370 370 # $3 dataset
371 371 #
372 372 function verify_send
373 373 {
374 374 typeset user=$1
375 375 typeset perm=$2
376 376 typeset dtst=$3
377 377
378 378 typeset oldval
379 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
379 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
380 380 typeset snap=$dtst@snap.$stamp
381 381
382 382 typeset -i ret=1
383 383
384 - log_must $ZFS snapshot $snap
384 + log_must zfs snapshot $snap
385 385 typeset bak_user=/tmp/bak.$user.$stamp
386 386 typeset bak_root=/tmp/bak.root.$stamp
387 387
388 - user_run $user eval "$ZFS send $snap > $bak_user"
389 - log_must eval "$ZFS send $snap > $bak_root"
388 + user_run $user eval "zfs send $snap > $bak_user"
389 + log_must eval "zfs send $snap > $bak_root"
390 390
391 391 if [[ $(checksum $bak_user) == $(checksum $bak_root) ]]; then
392 392 ret=0
393 393 fi
394 394
395 - $RM -rf $bak_user > /dev/null
396 - $RM -rf $bak_root > /dev/null
395 + rm -rf $bak_user > /dev/null
396 + rm -rf $bak_root > /dev/null
397 397
398 398 return $ret
399 399 }
400 400
401 401 function verify_fs_receive
402 402 {
403 403 typeset user=$1
404 404 typeset perm=$2
405 405 typeset fs=$3
406 406
407 407 typeset dtst
408 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
408 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
409 409 typeset newfs=$fs/newfs.$stamp
410 410 typeset newvol=$fs/newvol.$stamp
411 411 typeset bak_user=/tmp/bak.$user.$stamp
412 412 typeset bak_root=/tmp/bak.root.$stamp
413 413
414 - log_must $ZFS create $newfs
414 + log_must zfs create $newfs
415 415 typeset datasets="$newfs"
416 416 if is_global_zone ; then
417 - log_must $ZFS create -V $VOLSIZE $newvol
417 + log_must zfs create -V $VOLSIZE $newvol
418 418 datasets="$newfs $newvol"
419 419 fi
420 420
421 421 for dtst in $datasets ; do
422 422
423 423 typeset dtstsnap=$dtst@snap.$stamp
424 - log_must $ZFS snapshot $dtstsnap
424 + log_must zfs snapshot $dtstsnap
425 425
426 - log_must eval "$ZFS send $dtstsnap > $bak_root"
427 - log_must $ZFS destroy -rf $dtst
426 + log_must eval "zfs send $dtstsnap > $bak_root"
427 + log_must zfs destroy -rf $dtst
428 428
429 - user_run $user eval "$ZFS receive $dtst < $bak_root"
429 + user_run $user eval "zfs receive $dtst < $bak_root"
430 430 if datasetexists $dtstsnap ; then
431 431 return 1
432 432 fi
433 433
434 - log_must $ZFS allow $user create $fs
435 - user_run $user eval "$ZFS receive $dtst < $bak_root"
436 - log_must $ZFS unallow $user create $fs
434 + log_must zfs allow $user create $fs
435 + user_run $user eval "zfs receive $dtst < $bak_root"
436 + log_must zfs unallow $user create $fs
437 437 if datasetexists $dtstsnap ; then
438 438 return 1
439 439 fi
440 440
441 - log_must $ZFS allow $user mount $fs
442 - user_run $user eval "$ZFS receive $dtst < $bak_root"
443 - log_must $ZFS unallow $user mount $fs
441 + log_must zfs allow $user mount $fs
442 + user_run $user eval "zfs receive $dtst < $bak_root"
443 + log_must zfs unallow $user mount $fs
444 444 if datasetexists $dtstsnap ; then
445 445 return 1
446 446 fi
447 447
448 - log_must $ZFS allow $user mount,create $fs
449 - user_run $user eval "$ZFS receive $dtst < $bak_root"
450 - log_must $ZFS unallow $user mount,create $fs
448 + log_must zfs allow $user mount,create $fs
449 + user_run $user eval "zfs receive $dtst < $bak_root"
450 + log_must zfs unallow $user mount,create $fs
451 451 if ! datasetexists $dtstsnap ; then
452 452 return 1
453 453 fi
454 454
455 455 # check the data integrity
456 - log_must eval "$ZFS send $dtstsnap > $bak_user"
457 - log_must $ZFS destroy -rf $dtst
458 - log_must eval "$ZFS receive $dtst < $bak_root"
459 - log_must eval "$ZFS send $dtstsnap > $bak_root"
460 - log_must $ZFS destroy -rf $dtst
456 + log_must eval "zfs send $dtstsnap > $bak_user"
457 + log_must zfs destroy -rf $dtst
458 + log_must eval "zfs receive $dtst < $bak_root"
459 + log_must eval "zfs send $dtstsnap > $bak_root"
460 + log_must zfs destroy -rf $dtst
461 461 if [[ $(checksum $bak_user) != $(checksum $bak_root) ]]; then
462 462 return 1
463 463 fi
464 464
465 - $RM -rf $bak_user > /dev/null
466 - $RM -rf $bak_root > /dev/null
465 + rm -rf $bak_user > /dev/null
466 + rm -rf $bak_root > /dev/null
467 467
468 468 done
469 469
470 470 return 0
471 471 }
472 472
473 473 function verify_userprop
474 474 {
475 475 typeset user=$1
476 476 typeset perm=$2
477 477 typeset dtst=$3
478 478
479 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
479 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
480 480
481 - user_run $user $ZFS set "$user:ts=$stamp" $dtst
481 + user_run $user zfs set "$user:ts=$stamp" $dtst
482 482 if [[ $stamp != $(get_prop "$user:ts" $dtst) ]]; then
483 483 return 1
484 484 fi
485 485
486 486 return 0
487 487 }
488 488
489 489 function verify_ccr
490 490 {
491 491 typeset user=$1
492 492 typeset perm=$2
493 493 typeset dtst=$3
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
494 494
495 495 typeset oldval
496 496
497 497 set -A modes "on" "off"
498 498 oldval=$(get_prop $perm $dtst)
499 499 if [[ $oldval == "on" ]]; then
500 500 n=1
501 501 elif [[ $oldval == "off" ]]; then
502 502 n=0
503 503 fi
504 - log_note "$user $ZFS set $perm=${modes[$n]} $dtst"
505 - user_run $user $ZFS set $perm=${modes[$n]} $dtst
504 + log_note "$user zfs set $perm=${modes[$n]} $dtst"
505 + user_run $user zfs set $perm=${modes[$n]} $dtst
506 506 if [[ ${modes[$n]} != $(get_prop $perm $dtst) ]]; then
507 507 return 1
508 508 fi
509 509
510 510 return 0
511 511 }
512 512
513 513 function verify_copies
514 514 {
515 515 typeset user=$1
516 516 typeset perm=$2
517 517 typeset dtst=$3
518 518
519 519 typeset oldval
|
↓ open down ↓ |
4 lines elided |
↑ open up ↑ |
520 520
521 521 set -A modes 1 2 3
522 522 oldval=$(get_prop $perm $dtst)
523 523 if [[ $oldval -eq 1 ]]; then
524 524 n=1
525 525 elif [[ $oldval -eq 2 ]]; then
526 526 n=2
527 527 elif [[ $oldval -eq 3 ]]; then
528 528 n=0
529 529 fi
530 - log_note "$user $ZFS set $perm=${modes[$n]} $dtst"
531 - user_run $user $ZFS set $perm=${modes[$n]} $dtst
530 + log_note "$user zfs set $perm=${modes[$n]} $dtst"
531 + user_run $user zfs set $perm=${modes[$n]} $dtst
532 532 if [[ ${modes[$n]} != $(get_prop $perm $dtst) ]]; then
533 533 return 1
534 534 fi
535 535
536 536 return 0
537 537 }
538 538
539 539 function verify_reservation
540 540 {
541 541 typeset user=$1
542 542 typeset perm=$2
543 543 typeset dtst=$3
544 544
545 545 typeset value32m=$(( 1024 * 1024 * 32 ))
546 546 typeset oldval=$(get_prop reservation $dtst)
547 - user_run $user $ZFS set reservation=$value32m $dtst
547 + user_run $user zfs set reservation=$value32m $dtst
548 548 if [[ $value32m != $(get_prop reservation $dtst) ]]; then
549 - log_must $ZFS set reservation=$oldval $dtst
549 + log_must zfs set reservation=$oldval $dtst
550 550 return 1
551 551 fi
552 552
553 - log_must $ZFS set reservation=$oldval $dtst
553 + log_must zfs set reservation=$oldval $dtst
554 554 return 0
555 555 }
556 556
557 557 function verify_fs_create
558 558 {
559 559 typeset user=$1
560 560 typeset perm=$2
561 561 typeset fs=$3
562 562
563 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
563 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
564 564 typeset newfs=$fs/nfs.$stamp
565 565 typeset newvol=$fs/nvol.$stamp
566 566
567 - user_run $user $ZFS create $newfs
567 + user_run $user zfs create $newfs
568 568 if datasetexists $newfs ; then
569 569 return 1
570 570 fi
571 571
572 - log_must $ZFS allow $user mount $fs
573 - user_run $user $ZFS create $newfs
574 - log_must $ZFS unallow $user mount $fs
572 + log_must zfs allow $user mount $fs
573 + user_run $user zfs create $newfs
574 + log_must zfs unallow $user mount $fs
575 575 if ! datasetexists $newfs ; then
576 576 return 1
577 577 fi
578 578
579 - log_must $ZFS destroy $newfs
579 + log_must zfs destroy $newfs
580 580
581 581 if is_global_zone ; then
582 582 # mount permission is required for sparse volume
583 - user_run $user $ZFS create -V 150m -s $newvol
583 + user_run $user zfs create -V 150m -s $newvol
584 584 if datasetexists $newvol ; then
585 585 return 1
586 586 fi
587 587
588 - log_must $ZFS allow $user mount $fs
589 - user_run $user $ZFS create -V 150m -s $newvol
590 - log_must $ZFS unallow $user mount $fs
588 + log_must zfs allow $user mount $fs
589 + user_run $user zfs create -V 150m -s $newvol
590 + log_must zfs unallow $user mount $fs
591 591 if ! datasetexists $newvol ; then
592 592 return 1
593 593 fi
594 - log_must $ZFS destroy $newvol
594 + log_must zfs destroy $newvol
595 595
596 596 # mount and reserveration permission are
597 597 # required for normal volume
598 - user_run $user $ZFS create -V 150m $newvol
598 + user_run $user zfs create -V 150m $newvol
599 599 if datasetexists $newvol ; then
600 600 return 1
601 601 fi
602 602
603 - log_must $ZFS allow $user mount $fs
604 - user_run $user $ZFS create -V 150m $newvol
605 - log_must $ZFS unallow $user mount $fs
603 + log_must zfs allow $user mount $fs
604 + user_run $user zfs create -V 150m $newvol
605 + log_must zfs unallow $user mount $fs
606 606 if datasetexists $newvol ; then
607 607 return 1
608 608 fi
609 609
610 - log_must $ZFS allow $user reservation $fs
611 - user_run $user $ZFS create -V 150m $newvol
612 - log_must $ZFS unallow $user reservation $fs
610 + log_must zfs allow $user reservation $fs
611 + user_run $user zfs create -V 150m $newvol
612 + log_must zfs unallow $user reservation $fs
613 613 if datasetexists $newvol ; then
614 614 return 1
615 615 fi
616 616
617 - log_must $ZFS allow $user refreservation $fs
618 - user_run $user $ZFS create -V 150m $newvol
619 - log_must $ZFS unallow $user refreservation $fs
617 + log_must zfs allow $user refreservation $fs
618 + user_run $user zfs create -V 150m $newvol
619 + log_must zfs unallow $user refreservation $fs
620 620 if datasetexists $newvol ; then
621 621 return 1
622 622 fi
623 623
624 - log_must $ZFS allow $user mount $fs
625 - log_must $ZFS allow $user reservation $fs
626 - log_must $ZFS allow $user refreservation $fs
627 - user_run $user $ZFS create -V 150m $newvol
628 - log_must $ZFS unallow $user mount $fs
629 - log_must $ZFS unallow $user reservation $fs
630 - log_must $ZFS unallow $user refreservation $fs
624 + log_must zfs allow $user mount $fs
625 + log_must zfs allow $user reservation $fs
626 + log_must zfs allow $user refreservation $fs
627 + user_run $user zfs create -V 150m $newvol
628 + log_must zfs unallow $user mount $fs
629 + log_must zfs unallow $user reservation $fs
630 + log_must zfs unallow $user refreservation $fs
631 631 if ! datasetexists $newvol ; then
632 632 return 1
633 633 fi
634 - log_must $ZFS destroy $newvol
634 + log_must zfs destroy $newvol
635 635 fi
636 636
637 637 return 0
638 638 }
639 639
640 640 function verify_fs_destroy
641 641 {
642 642 typeset user=$1
643 643 typeset perm=$2
644 644 typeset fs=$3
645 645
646 646 if ! ismounted $fs ; then
647 - user_run $user $ZFS destroy $fs
647 + user_run $user zfs destroy $fs
648 648 if datasetexists $fs ; then
649 649 return 1
650 650 fi
651 651 fi
652 652
653 653 if ismounted $fs ; then
654 - user_run $user $ZFS destroy $fs
654 + user_run $user zfs destroy $fs
655 655 if ! datasetexists $fs ; then
656 656 return 1
657 657 fi
658 658
659 659 # mount permission is required
660 - log_must $ZFS allow $user mount $fs
661 - user_run $user $ZFS destroy $fs
660 + log_must zfs allow $user mount $fs
661 + user_run $user zfs destroy $fs
662 662 if datasetexists $fs ; then
663 663 return 1
664 664 fi
665 665 fi
666 666
667 667 return 0
668 668 }
669 669
670 670 # Verify that given the correct delegation, a regular user can:
671 671 # Take a snapshot of an unmounted dataset
672 672 # Take a snapshot of an mounted dataset
673 673 # Create a snapshot by making a directory in the .zfs/snapshot directory
674 674 function verify_fs_snapshot
675 675 {
676 676 typeset user=$1
677 677 typeset perm=$2
678 678 typeset fs=$3
679 679
680 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
680 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
681 681 typeset snap=$fs@snap.$stamp
682 682 typeset mntpt=$(get_prop mountpoint $fs)
683 683
684 684 if [[ "yes" == $(get_prop mounted $fs) ]]; then
685 - log_must $ZFS umount $fs
685 + log_must zfs umount $fs
686 686 fi
687 687
688 - user_run $user $ZFS snapshot $snap
688 + user_run $user zfs snapshot $snap
689 689 if ! datasetexists $snap ; then
690 690 return 1
691 691 fi
692 - log_must $ZFS destroy $snap
692 + log_must zfs destroy $snap
693 693
694 694 if [[ "no" == $(get_prop mounted $fs) ]]; then
695 - log_must $ZFS mount $fs
695 + log_must zfs mount $fs
696 696 fi
697 697
698 - user_run $user $ZFS snapshot $snap
698 + user_run $user zfs snapshot $snap
699 699 if ! datasetexists $snap ; then
700 700 return 1
701 701 fi
702 - log_must $ZFS destroy $snap
702 + log_must zfs destroy $snap
703 703
704 704 typeset snapdir=${mntpt}/.zfs/snapshot/snap.$stamp
705 - user_run $user $MKDIR $snapdir
705 + user_run $user mkdir $snapdir
706 706 if ! datasetexists $snap ; then
707 707 return 1
708 708 fi
709 - log_must $ZFS destroy $snap
709 + log_must zfs destroy $snap
710 710
711 711 return 0
712 712 }
713 713
714 714 function verify_fs_rollback
715 715 {
716 716 typeset user=$1
717 717 typeset perm=$2
718 718 typeset fs=$3
719 719
720 720 typeset oldval
721 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
721 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
722 722 typeset snap=$fs@snap.$stamp
723 723 typeset mntpt=$(get_prop mountpoint $fs)
724 724
725 725 oldval=$(datasetcksum $fs)
726 - log_must $ZFS snapshot $snap
726 + log_must zfs snapshot $snap
727 727
728 728 if ! ismounted $fs; then
729 - log_must $ZFS mount $fs
729 + log_must zfs mount $fs
730 730 fi
731 - log_must $TOUCH $mntpt/testfile.$stamp
731 + log_must touch $mntpt/testfile.$stamp
732 732
733 - user_run $user $ZFS rollback -R $snap
733 + user_run $user zfs rollback -R $snap
734 734 if is_global_zone ; then
735 735 if [[ $oldval != $(datasetcksum $fs) ]]; then
736 736 return 1
737 737 fi
738 738 else
739 739 # datasetcksum can not be used in local zone
740 740 if [[ -e $mntpt/testfile.$stamp ]]; then
741 741 return 1
742 742 fi
743 743 fi
744 744
745 745 return 0
746 746 }
747 747
748 748 function verify_fs_clone
749 749 {
750 750 typeset user=$1
751 751 typeset perm=$2
752 752 typeset fs=$3
753 753
754 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
754 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
755 755 typeset basefs=${fs%/*}
756 756 typeset snap=$fs@snap.$stamp
757 757 typeset clone=$basefs/cfs.$stamp
758 758
759 - log_must $ZFS snapshot $snap
760 - user_run $user $ZFS clone $snap $clone
759 + log_must zfs snapshot $snap
760 + user_run $user zfs clone $snap $clone
761 761 if datasetexists $clone ; then
762 762 return 1
763 763 fi
764 764
765 - log_must $ZFS allow $user create $basefs
766 - user_run $user $ZFS clone $snap $clone
767 - log_must $ZFS unallow $user create $basefs
765 + log_must zfs allow $user create $basefs
766 + user_run $user zfs clone $snap $clone
767 + log_must zfs unallow $user create $basefs
768 768 if datasetexists $clone ; then
769 769 return 1
770 770 fi
771 771
772 - log_must $ZFS allow $user mount $basefs
773 - user_run $user $ZFS clone $snap $clone
774 - log_must $ZFS unallow $user mount $basefs
772 + log_must zfs allow $user mount $basefs
773 + user_run $user zfs clone $snap $clone
774 + log_must zfs unallow $user mount $basefs
775 775 if datasetexists $clone ; then
776 776 return 1
777 777 fi
778 778
779 - log_must $ZFS allow $user mount $basefs
780 - log_must $ZFS allow $user create $basefs
781 - user_run $user $ZFS clone $snap $clone
782 - log_must $ZFS unallow $user create $basefs
783 - log_must $ZFS unallow $user mount $basefs
779 + log_must zfs allow $user mount $basefs
780 + log_must zfs allow $user create $basefs
781 + user_run $user zfs clone $snap $clone
782 + log_must zfs unallow $user create $basefs
783 + log_must zfs unallow $user mount $basefs
784 784 if ! datasetexists $clone ; then
785 785 return 1
786 786 fi
787 787
788 - log_must $ZFS destroy -R $snap
788 + log_must zfs destroy -R $snap
789 789
790 790 return 0
791 791 }
792 792
793 793 function verify_fs_rename
794 794 {
795 795 typeset user=$1
796 796 typeset perm=$2
797 797 typeset fs=$3
798 798
799 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
799 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
800 800 typeset basefs=${fs%/*}
801 801 typeset snap=$fs@snap.$stamp
802 802 typeset renamefs=$basefs/nfs.$stamp
803 803
804 804 if ! ismounted $fs; then
805 - log_must $ZFS mount $fs
805 + log_must zfs mount $fs
806 806 fi
807 807
808 808 # case 1
809 - user_run $user $ZFS rename $fs $renamefs
809 + user_run $user zfs rename $fs $renamefs
810 810 if datasetexists $renamefs ; then
811 811 return 1
812 812 fi
813 813
814 814 # case 2
815 - log_must $ZFS allow $user create $basefs
816 - user_run $user $ZFS rename $fs $renamefs
817 - log_must $ZFS unallow $user create $basefs
815 + log_must zfs allow $user create $basefs
816 + user_run $user zfs rename $fs $renamefs
817 + log_must zfs unallow $user create $basefs
818 818 if datasetexists $renamefs ; then
819 819 return 1
820 820 fi
821 821
822 822 # case 3
823 - log_must $ZFS allow $user mount $basefs
824 - user_run $user $ZFS rename $fs $renamefs
825 - log_must $ZFS unallow $user mount $basefs
823 + log_must zfs allow $user mount $basefs
824 + user_run $user zfs rename $fs $renamefs
825 + log_must zfs unallow $user mount $basefs
826 826 if datasetexists $renamefs ; then
827 827 return 1
828 828 fi
829 829
830 830 # case 4
831 - log_must $ZFS allow $user mount $fs
832 - user_run $user $ZFS rename $fs $renamefs
831 + log_must zfs allow $user mount $fs
832 + user_run $user zfs rename $fs $renamefs
833 833 if datasetexists $renamefs ; then
834 - log_must $ZFS unallow $user mount $renamefs
834 + log_must zfs unallow $user mount $renamefs
835 835 return 1
836 836 fi
837 - log_must $ZFS unallow $user mount $fs
837 + log_must zfs unallow $user mount $fs
838 838
839 839 # case 5
840 - log_must $ZFS allow $user create $basefs
841 - log_must $ZFS allow $user mount $fs
842 - user_run $user $ZFS rename $fs $renamefs
843 - log_must $ZFS unallow $user create $basefs
840 + log_must zfs allow $user create $basefs
841 + log_must zfs allow $user mount $fs
842 + user_run $user zfs rename $fs $renamefs
843 + log_must zfs unallow $user create $basefs
844 844 if datasetexists $renamefs ; then
845 - log_must $ZFS unallow $user mount $renamefs
845 + log_must zfs unallow $user mount $renamefs
846 846 return 1
847 847 fi
848 - log_must $ZFS unallow $user mount $fs
848 + log_must zfs unallow $user mount $fs
849 849
850 850 # case 6
851 - log_must $ZFS allow $user mount $basefs
852 - log_must $ZFS allow $user mount $fs
853 - user_run $user $ZFS rename $fs $renamefs
854 - log_must $ZFS unallow $user mount $basefs
851 + log_must zfs allow $user mount $basefs
852 + log_must zfs allow $user mount $fs
853 + user_run $user zfs rename $fs $renamefs
854 + log_must zfs unallow $user mount $basefs
855 855 if datasetexists $renamefs ; then
856 - log_must $ZFS unallow $user mount $renamefs
856 + log_must zfs unallow $user mount $renamefs
857 857 return 1
858 858 fi
859 - log_must $ZFS unallow $user mount $fs
859 + log_must zfs unallow $user mount $fs
860 860
861 861 # case 7
862 - log_must $ZFS allow $user create $basefs
863 - log_must $ZFS allow $user mount $basefs
864 - user_run $user $ZFS rename $fs $renamefs
865 - log_must $ZFS unallow $user mount $basefs
866 - log_must $ZFS unallow $user create $basefs
862 + log_must zfs allow $user create $basefs
863 + log_must zfs allow $user mount $basefs
864 + user_run $user zfs rename $fs $renamefs
865 + log_must zfs unallow $user mount $basefs
866 + log_must zfs unallow $user create $basefs
867 867 if ! datasetexists $renamefs ; then
868 868 return 1
869 869 fi
870 870
871 - log_must $ZFS rename $renamefs $fs
871 + log_must zfs rename $renamefs $fs
872 872
873 873 return 0
874 874 }
875 875
876 876 function verify_fs_mount
877 877 {
878 878 typeset user=$1
879 879 typeset perm=$2
880 880 typeset fs=$3
881 881
882 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
882 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
883 883 typeset mntpt=$(get_prop mountpoint $fs)
884 884 typeset newmntpt=/tmp/mnt.$stamp
885 885
886 886 if ismounted $fs ; then
887 - user_run $user $ZFS unmount $fs
887 + user_run $user zfs unmount $fs
888 888 if ismounted $fs ; then
889 889 return 1
890 890 fi
891 891 fi
892 892
893 893 if ! ismounted $fs ; then
894 - log_must $ZFS set mountpoint=$newmntpt $fs
895 - log_must $RM -rf $newmntpt
896 - log_must $MKDIR $newmntpt
894 + log_must zfs set mountpoint=$newmntpt $fs
895 + log_must rm -rf $newmntpt
896 + log_must mkdir $newmntpt
897 897
898 - user_run $user $ZFS mount $fs
898 + user_run $user zfs mount $fs
899 899 if ismounted $fs ; then
900 900 return 1
901 901 fi
902 902
903 903 # mountpoint's owner must be the user
904 - log_must $CHOWN $user $newmntpt
905 - user_run $user $ZFS mount $fs
904 + log_must chown $user $newmntpt
905 + user_run $user zfs mount $fs
906 906 if ! ismounted $fs ; then
907 907 return 1
908 908 fi
909 - log_must $ZFS umount $fs
910 - log_must $RM -rf $newmntpt
911 - log_must $ZFS set mountpoint=$mntpt $fs
909 + log_must zfs umount $fs
910 + log_must rm -rf $newmntpt
911 + log_must zfs set mountpoint=$mntpt $fs
912 912 fi
913 913
914 914 return 0
915 915 }
916 916
917 917 function verify_fs_share
918 918 {
919 919 typeset user=$1
920 920 typeset perm=$2
921 921 typeset fs=$3
922 922 typeset -i ret=0
923 923
924 - $SVCADM enable -rs nfs/server
925 - typeset stat=$($SVCS -H -o STA nfs/server:default)
924 + svcadm enable -rs nfs/server
925 + typeset stat=$(svcs -H -o STA nfs/server:default)
926 926 if [[ $stat != "ON" ]]; then
927 927 log_fail "Could not enable nfs/server"
928 928 fi
929 929
930 - log_must $ZFS set sharenfs=on $fs
931 - $ZFS unshare $fs
930 + log_must zfs set sharenfs=on $fs
931 + zfs unshare $fs
932 932
933 - user_run $user $ZFS share $fs
933 + user_run $user zfs share $fs
934 934 if ! is_shared $fs; then
935 935 ret=1
936 936 fi
937 937
938 - $ZFS unshare $fs
939 - log_must $ZFS set sharenfs=off $fs
938 + zfs unshare $fs
939 + log_must zfs set sharenfs=off $fs
940 940
941 941 return $ret
942 942 }
943 943
944 944 function verify_fs_mountpoint
945 945 {
946 946 typeset user=$1
947 947 typeset perm=$2
948 948 typeset fs=$3
949 949
950 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
950 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
951 951 typeset mntpt=$(get_prop mountpoint $fs)
952 952 typeset newmntpt=/tmp/mnt.$stamp
953 953
954 954 if ! ismounted $fs ; then
955 - user_run $user $ZFS set mountpoint=$newmntpt $fs
955 + user_run $user zfs set mountpoint=$newmntpt $fs
956 956 if [[ $newmntpt != \
957 957 $(get_prop mountpoint $fs) ]] ; then
958 958 return 1
959 959 fi
960 - log_must $ZFS set mountpoint=$mntpt $fs
960 + log_must zfs set mountpoint=$mntpt $fs
961 961 fi
962 962
963 963 if ismounted $fs ; then
964 - user_run $user $ZFS set mountpoint=$newmntpt $fs
964 + user_run $user zfs set mountpoint=$newmntpt $fs
965 965 if [[ $mntpt != $(get_prop mountpoint $fs) ]]; then
966 966 return 1
967 967 fi
968 968
969 969 # require mount permission when fs is mounted
970 - log_must $ZFS allow $user mount $fs
971 - user_run $user $ZFS set mountpoint=$newmntpt $fs
972 - log_must $ZFS unallow $user mount $fs
970 + log_must zfs allow $user mount $fs
971 + user_run $user zfs set mountpoint=$newmntpt $fs
972 + log_must zfs unallow $user mount $fs
973 973 if [[ $newmntpt != \
974 974 $(get_prop mountpoint $fs) ]] ; then
975 975 return 1
976 976 fi
977 - log_must $ZFS set mountpoint=$mntpt $fs
977 + log_must zfs set mountpoint=$mntpt $fs
978 978 fi
979 979
980 980 return 0
981 981 }
982 982
983 983 function verify_fs_promote
984 984 {
985 985 typeset user=$1
986 986 typeset perm=$2
987 987 typeset fs=$3
988 988
989 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
989 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
990 990 typeset basefs=${fs%/*}
991 991 typeset snap=$fs@snap.$stamp
992 992 typeset clone=$basefs/cfs.$stamp
993 993
994 - log_must $ZFS snapshot $snap
995 - log_must $ZFS clone $snap $clone
996 - log_must $ZFS promote $clone
994 + log_must zfs snapshot $snap
995 + log_must zfs clone $snap $clone
996 + log_must zfs promote $clone
997 997
998 998 typeset fs_orig=$(get_prop origin $fs)
999 999 typeset clone_orig=$(get_prop origin $clone)
1000 1000
1001 - user_run $user $ZFS promote $fs
1001 + user_run $user zfs promote $fs
1002 1002 # promote should fail if original fs does not have
1003 1003 # promote permission
1004 1004 if [[ $fs_orig != $(get_prop origin $fs) || \
1005 1005 $clone_orig != $(get_prop origin $clone) ]]; then
1006 1006 return 1
1007 1007 fi
1008 1008
1009 - log_must $ZFS allow $user promote $clone
1010 - user_run $user $ZFS promote $fs
1011 - log_must $ZFS unallow $user promote $clone
1009 + log_must zfs allow $user promote $clone
1010 + user_run $user zfs promote $fs
1011 + log_must zfs unallow $user promote $clone
1012 1012 if [[ $fs_orig != $(get_prop origin $fs) || \
1013 1013 $clone_orig != $(get_prop origin $clone) ]]; then
1014 1014 return 1
1015 1015 fi
1016 1016
1017 - log_must $ZFS allow $user mount $fs
1018 - user_run $user $ZFS promote $fs
1019 - log_must $ZFS unallow $user mount $fs
1017 + log_must zfs allow $user mount $fs
1018 + user_run $user zfs promote $fs
1019 + log_must zfs unallow $user mount $fs
1020 1020 if [[ $fs_orig != $(get_prop origin $fs) || \
1021 1021 $clone_orig != $(get_prop origin $clone) ]]; then
1022 1022 return 1
1023 1023 fi
1024 1024
1025 - log_must $ZFS allow $user mount $fs
1026 - log_must $ZFS allow $user promote $clone
1027 - user_run $user $ZFS promote $fs
1028 - log_must $ZFS unallow $user promote $clone
1029 - log_must $ZFS unallow $user mount $fs
1025 + log_must zfs allow $user mount $fs
1026 + log_must zfs allow $user promote $clone
1027 + user_run $user zfs promote $fs
1028 + log_must zfs unallow $user promote $clone
1029 + log_must zfs unallow $user mount $fs
1030 1030 if [[ $snap != $(get_prop origin $clone) || \
1031 1031 $clone_orig != $(get_prop origin $fs) ]]; then
1032 1032 return 1
1033 1033 fi
1034 1034
1035 1035 return 0
1036 1036 }
1037 1037
1038 1038 function verify_fs_canmount
1039 1039 {
1040 1040 typeset user=$1
1041 1041 typeset perm=$2
1042 1042 typeset fs=$3
1043 1043
1044 1044 typeset oldval
1045 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1045 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1046 1046
1047 1047 if ! ismounted $fs ; then
1048 1048 set -A modes "on" "off"
1049 1049 oldval=$(get_prop $perm $fs)
1050 1050 if [[ $oldval == "on" ]]; then
1051 1051 n=1
1052 1052 elif [[ $oldval == "off" ]]; then
1053 1053 n=0
1054 1054 fi
1055 - log_note "$user $ZFS set $perm=${modes[$n]} $fs"
1056 - user_run $user $ZFS set $perm=${modes[$n]} $fs
1055 + log_note "$user zfs set $perm=${modes[$n]} $fs"
1056 + user_run $user zfs set $perm=${modes[$n]} $fs
1057 1057 if [[ ${modes[$n]} != $(get_prop $perm $fs) ]]; then
1058 1058 return 1
1059 1059 fi
1060 1060 fi
1061 1061
1062 1062
1063 1063 # fs is mounted
1064 1064 if ismounted $fs ; then
1065 1065 # property value does not change if
1066 1066 # no mount permission
1067 1067 set -A modes "on" "off"
1068 1068 oldval=$(get_prop $perm $fs)
1069 1069 if [[ $oldval == "on" ]]; then
1070 1070 n=1
1071 1071 elif [[ $oldval == "off" ]]; then
1072 1072 n=0
1073 1073 fi
1074 - log_note "$user $ZFS set $perm=${modes[$n]} $fs"
1075 - log_must $ZFS allow $user mount $fs
1076 - user_run $user $ZFS set $perm=${modes[$n]} $fs
1077 - log_must $ZFS unallow $user mount $fs
1074 + log_note "$user zfs set $perm=${modes[$n]} $fs"
1075 + log_must zfs allow $user mount $fs
1076 + user_run $user zfs set $perm=${modes[$n]} $fs
1077 + log_must zfs unallow $user mount $fs
1078 1078 if [[ ${modes[$n]} != $(get_prop $perm $fs) ]]; then
1079 1079 return 1
1080 1080 fi
1081 1081 fi
1082 1082
1083 1083 return 0
1084 1084 }
1085 1085
1086 1086 function verify_fs_recordsize
1087 1087 {
1088 1088 typeset user=$1
1089 1089 typeset perm=$2
1090 1090 typeset fs=$3
1091 1091
1092 1092 typeset value8k=$(( 1024 * 8 ))
1093 - user_run $user $ZFS set recordsize=$value8k $fs
1093 + user_run $user zfs set recordsize=$value8k $fs
1094 1094 if [[ $value8k != $(get_prop recordsize $fs) ]]; then
1095 1095 return 1
1096 1096 fi
1097 1097
1098 1098 return 0
1099 1099 }
1100 1100
1101 1101 function verify_fs_quota
1102 1102 {
1103 1103 typeset user=$1
1104 1104 typeset perm=$2
1105 1105 typeset fs=$3
1106 1106
1107 1107 typeset value32m=$(( 1024 * 1024 * 32 ))
1108 - user_run $user $ZFS set quota=$value32m $fs
1108 + user_run $user zfs set quota=$value32m $fs
1109 1109 if [[ $value32m != $(get_prop quota $fs) ]]; then
1110 1110 return 1
1111 1111 fi
1112 1112
1113 1113 return 0
1114 1114 }
1115 1115
1116 1116 function verify_fs_aclmode
1117 1117 {
1118 1118 typeset user=$1
1119 1119 typeset perm=$2
1120 1120 typeset fs=$3
1121 1121
|
↓ open down ↓ |
3 lines elided |
↑ open up ↑ |
1122 1122 typeset oldval
1123 1123 set -A modes "discard" "groupmask" "passthrough"
1124 1124 oldval=$(get_prop $perm $fs)
1125 1125 if [[ $oldval == "discard" ]]; then
1126 1126 n=1
1127 1127 elif [[ $oldval == "groupmask" ]]; then
1128 1128 n=2
1129 1129 elif [[ $oldval == "passthrough" ]]; then
1130 1130 n=0
1131 1131 fi
1132 - log_note "$user $ZFS set aclmode=${modes[$n]} $fs"
1133 - user_run $user $ZFS set aclmode=${modes[$n]} $fs
1132 + log_note "$user zfs set aclmode=${modes[$n]} $fs"
1133 + user_run $user zfs set aclmode=${modes[$n]} $fs
1134 1134 if [[ ${modes[$n]} != $(get_prop aclmode $fs) ]]; then
1135 1135 return 1
1136 1136 fi
1137 1137
1138 1138 return 0
1139 1139 }
1140 1140
1141 1141 function verify_fs_aclinherit
1142 1142 {
1143 1143 typeset user=$1
1144 1144 typeset perm=$2
1145 1145 typeset fs=$3
1146 1146
1147 1147 #
1148 1148 # PSARC/2008/231 change the default value of aclinherit to "restricted"
1149 1149 # but still keep the old interface of "secure"
1150 1150 #
1151 1151
1152 1152 typeset oldval
1153 1153 set -A modes "discard" "noallow" "secure" "passthrough"
|
↓ open down ↓ |
10 lines elided |
↑ open up ↑ |
1154 1154 oldval=$(get_prop $perm $fs)
1155 1155 if [[ $oldval == "discard" ]]; then
1156 1156 n=1
1157 1157 elif [[ $oldval == "noallow" ]]; then
1158 1158 n=2
1159 1159 elif [[ $oldval == "secure" || $oldval == "restricted" ]]; then
1160 1160 n=3
1161 1161 elif [[ $oldval == "passthrough" ]]; then
1162 1162 n=0
1163 1163 fi
1164 - log_note "$user $ZFS set aclinherit=${modes[$n]} $fs"
1165 - user_run $user $ZFS set aclinherit=${modes[$n]} $fs
1164 + log_note "$user zfs set aclinherit=${modes[$n]} $fs"
1165 + user_run $user zfs set aclinherit=${modes[$n]} $fs
1166 1166
1167 1167 typeset newval=$(get_prop aclinherit $fs)
1168 1168 if [[ ${modes[$n]} == "secure" && $newval == "restricted" ]]; then
1169 1169 return 0
1170 1170 elif [[ ${modes[$n]} != $(get_prop aclinherit $fs) ]]; then
1171 1171 return 1
1172 1172 fi
1173 1173
1174 1174 return 0
1175 1175 }
1176 1176
1177 1177 function verify_fs_snapdir
1178 1178 {
1179 1179 typeset user=$1
1180 1180 typeset perm=$2
|
↓ open down ↓ |
5 lines elided |
↑ open up ↑ |
1181 1181 typeset fs=$3
1182 1182
1183 1183 typeset oldval
1184 1184 set -A modes "visible" "hidden"
1185 1185 oldval=$(get_prop $perm $fs)
1186 1186 if [[ $oldval == "visible" ]]; then
1187 1187 n=1
1188 1188 elif [[ $oldval == "hidden" ]]; then
1189 1189 n=0
1190 1190 fi
1191 - log_note "$user $ZFS set snapdir=${modes[$n]} $fs"
1192 - user_run $user $ZFS set snapdir=${modes[$n]} $fs
1191 + log_note "$user zfs set snapdir=${modes[$n]} $fs"
1192 + user_run $user zfs set snapdir=${modes[$n]} $fs
1193 1193 if [[ ${modes[$n]} != $(get_prop snapdir $fs) ]]; then
1194 1194 return 1
1195 1195 fi
1196 1196
1197 1197 return 0
1198 1198 }
1199 1199
1200 1200 function verify_fs_aedsx
1201 1201 {
1202 1202 typeset user=$1
1203 1203 typeset perm=$2
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
1204 1204 typeset fs=$3
1205 1205
1206 1206 typeset oldval
1207 1207 set -A modes "on" "off"
1208 1208 oldval=$(get_prop $perm $fs)
1209 1209 if [[ $oldval == "on" ]]; then
1210 1210 n=1
1211 1211 elif [[ $oldval == "off" ]]; then
1212 1212 n=0
1213 1213 fi
1214 - log_note "$user $ZFS set $perm=${modes[$n]} $fs"
1215 - user_run $user $ZFS set $perm=${modes[$n]} $fs
1214 + log_note "$user zfs set $perm=${modes[$n]} $fs"
1215 + user_run $user zfs set $perm=${modes[$n]} $fs
1216 1216 if [[ ${modes[$n]} != $(get_prop $perm $fs) ]]; then
1217 1217 return 1
1218 1218 fi
1219 1219
1220 1220 return 0
1221 1221 }
1222 1222
1223 1223 function verify_fs_zoned
1224 1224 {
1225 1225 typeset user=$1
1226 1226 typeset perm=$2
|
↓ open down ↓ |
1 lines elided |
↑ open up ↑ |
1227 1227 typeset fs=$3
1228 1228
1229 1229 typeset oldval
1230 1230 set -A modes "on" "off"
1231 1231 oldval=$(get_prop $perm $fs)
1232 1232 if [[ $oldval == "on" ]]; then
1233 1233 n=1
1234 1234 elif [[ $oldval == "off" ]]; then
1235 1235 n=0
1236 1236 fi
1237 - log_note "$user $ZFS set $perm=${modes[$n]} $fs"
1237 + log_note "$user zfs set $perm=${modes[$n]} $fs"
1238 1238 if is_global_zone ; then
1239 1239 if ! ismounted $fs ; then
1240 - user_run $user $ZFS set \
1240 + user_run $user zfs set \
1241 1241 $perm=${modes[$n]} $fs
1242 1242 if [[ ${modes[$n]} != \
1243 1243 $(get_prop $perm $fs) ]]; then
1244 1244 return 1
1245 1245 fi
1246 1246 if [[ $n -eq 0 ]]; then
1247 - log_mustnot $ZFS mount $fs
1247 + log_mustnot zfs mount $fs
1248 1248 else
1249 - log_must $ZFS mount $fs
1249 + log_must zfs mount $fs
1250 1250 fi
1251 1251 fi
1252 1252
1253 1253 if ismounted $fs; then
1254 1254 # n always is 1 in this case
1255 - user_run $user $ZFS set \
1255 + user_run $user zfs set \
1256 1256 $perm=${modes[$n]} $fs
1257 1257 if [[ $oldval != \
1258 1258 $(get_prop $perm $fs) ]]; then
1259 1259 return 1
1260 1260 fi
1261 1261
1262 1262 # mount permission is needed
1263 1263 # to make zoned=on
1264 - log_must $ZFS allow $user mount $fs
1265 - user_run $user $ZFS set \
1264 + log_must zfs allow $user mount $fs
1265 + user_run $user zfs set \
1266 1266 $perm=${modes[$n]} $fs
1267 - log_must $ZFS unallow $user mount $fs
1267 + log_must zfs unallow $user mount $fs
1268 1268 if [[ ${modes[$n]} != \
1269 1269 $(get_prop $perm $fs) ]]; then
1270 1270 return 1
1271 1271 fi
1272 1272 fi
1273 1273 fi
1274 1274
1275 1275 if ! is_global_zone; then
1276 - user_run $user $ZFS set $perm=${modes[$n]} $fs
1276 + user_run $user zfs set $perm=${modes[$n]} $fs
1277 1277 if [[ $oldval != $(get_prop $perm $fs) ]]; then
1278 1278 return 1
1279 1279 fi
1280 1280 fi
1281 1281
1282 1282 return 0
1283 1283 }
1284 1284
1285 1285 function verify_fs_sharenfs
1286 1286 {
1287 1287 typeset user=$1
1288 1288 typeset perm=$2
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
1289 1289 typeset fs=$3
1290 1290 typeset nmode omode
1291 1291
1292 1292 omode=$(get_prop $perm $fs)
1293 1293 if [[ $omode == "off" ]]; then
1294 1294 nmode="on"
1295 1295 else
1296 1296 nmode="off"
1297 1297 fi
1298 1298
1299 - log_note "$user $ZFS set $perm=$nmode $fs"
1300 - user_run $user $ZFS set $perm=$nmode $fs
1299 + log_note "$user zfs set $perm=$nmode $fs"
1300 + user_run $user zfs set $perm=$nmode $fs
1301 1301 if [[ $(get_prop $perm $fs) != $nmode ]]; then
1302 1302 return 1
1303 1303 fi
1304 1304
1305 - log_note "$user $ZFS set $perm=$omode $fs"
1306 - user_run $user $ZFS set $perm=$omode $fs
1305 + log_note "$user zfs set $perm=$omode $fs"
1306 + user_run $user zfs set $perm=$omode $fs
1307 1307 if [[ $(get_prop $perm $fs) != $omode ]]; then
1308 1308 return 1
1309 1309 fi
1310 1310
1311 1311 return 0
1312 1312 }
1313 1313
1314 1314 function verify_vol_destroy
1315 1315 {
1316 1316 typeset user=$1
1317 1317 typeset perm=$2
1318 1318 typeset vol=$3
1319 1319
1320 - user_run $user $ZFS destroy $vol
1320 + user_run $user zfs destroy $vol
1321 1321 if ! datasetexists $vol ; then
1322 1322 return 1
1323 1323 fi
1324 1324
1325 1325 # mount permission is required
1326 - log_must $ZFS allow $user mount $vol
1327 - user_run $user $ZFS destroy $vol
1326 + log_must zfs allow $user mount $vol
1327 + user_run $user zfs destroy $vol
1328 1328 if datasetexists $vol ; then
1329 1329 return 1
1330 1330 fi
1331 1331
1332 1332 return 0
1333 1333 }
1334 1334
1335 1335 function verify_vol_snapshot
1336 1336 {
1337 1337 typeset user=$1
1338 1338 typeset perm=$2
1339 1339 typeset vol=$3
1340 1340
1341 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1341 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1342 1342 typeset basevol=${vol%/*}
1343 1343 typeset snap=$vol@snap.$stamp
1344 1344
1345 - user_run $user $ZFS snapshot $snap
1345 + user_run $user zfs snapshot $snap
1346 1346 if datasetexists $snap ; then
1347 1347 return 1
1348 1348 fi
1349 1349
1350 - log_must $ZFS allow $user mount $vol
1351 - user_run $user $ZFS snapshot $snap
1352 - log_must $ZFS unallow $user mount $vol
1350 + log_must zfs allow $user mount $vol
1351 + user_run $user zfs snapshot $snap
1352 + log_must zfs unallow $user mount $vol
1353 1353 if ! datasetexists $snap ; then
1354 1354 return 1
1355 1355 fi
1356 1356
1357 1357 return 0
1358 1358 }
1359 1359
1360 1360 function verify_vol_rollback
1361 1361 {
1362 1362 typeset user=$1
1363 1363 typeset perm=$2
1364 1364 typeset vol=$3
1365 1365
1366 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1366 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1367 1367 typeset basevol=${vol%/*}
1368 1368 typeset snap=$vol@snap.$stamp
1369 1369
1370 1370 typeset oldval
1371 - log_must $ZFS snapshot $snap
1371 + log_must zfs snapshot $snap
1372 1372 oldval=$(datasetcksum $vol)
1373 1373
1374 - log_must $DD if=/dev/random of=/dev/zvol/rdsk/$vol \
1374 + log_must dd if=/dev/random of=/dev/zvol/rdsk/$vol \
1375 1375 bs=512 count=1
1376 1376
1377 - user_run $user $ZFS rollback -R $snap
1378 - $SLEEP 10
1377 + user_run $user zfs rollback -R $snap
1378 + sleep 10
1379 1379 if [[ $oldval == $(datasetcksum $vol) ]]; then
1380 1380 return 1
1381 1381 fi
1382 1382
1383 1383 # rollback on volume has to be with mount permission
1384 - log_must $ZFS allow $user mount $vol
1385 - user_run $user $ZFS rollback -R $snap
1386 - $SLEEP 10
1387 - log_must $ZFS unallow $user mount $vol
1384 + log_must zfs allow $user mount $vol
1385 + user_run $user zfs rollback -R $snap
1386 + sleep 10
1387 + log_must zfs unallow $user mount $vol
1388 1388 if [[ $oldval != $(datasetcksum $vol) ]]; then
1389 1389 return 1
1390 1390 fi
1391 1391
1392 1392 return 0
1393 1393 }
1394 1394
1395 1395 function verify_vol_clone
1396 1396 {
1397 1397 typeset user=$1
1398 1398 typeset perm=$2
1399 1399 typeset vol=$3
1400 1400
1401 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1401 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1402 1402 typeset basevol=${vol%/*}
1403 1403 typeset snap=$vol@snap.$stamp
1404 1404 typeset clone=$basevol/cvol.$stamp
1405 1405
1406 - log_must $ZFS snapshot $snap
1406 + log_must zfs snapshot $snap
1407 1407
1408 - user_run $user $ZFS clone $snap $clone
1408 + user_run $user zfs clone $snap $clone
1409 1409 if datasetexists $clone ; then
1410 1410 return 1
1411 1411 fi
1412 1412
1413 - log_must $ZFS allow $user create $basevol
1414 - user_run $user $ZFS clone $snap $clone
1415 - log_must $ZFS unallow $user create $basevol
1413 + log_must zfs allow $user create $basevol
1414 + user_run $user zfs clone $snap $clone
1415 + log_must zfs unallow $user create $basevol
1416 1416 if datasetexists $clone ; then
1417 1417 return 1
1418 1418 fi
1419 1419
1420 - log_must $ZFS allow $user mount $basevol
1421 - user_run $user $ZFS clone $snap $clone
1422 - log_must $ZFS unallow $user mount $basevol
1420 + log_must zfs allow $user mount $basevol
1421 + user_run $user zfs clone $snap $clone
1422 + log_must zfs unallow $user mount $basevol
1423 1423 if datasetexists $clone ; then
1424 1424 return 1
1425 1425 fi
1426 1426
1427 1427 # require create permission on parent and
1428 1428 # mount permission on itself as well
1429 - log_must $ZFS allow $user mount $basevol
1430 - log_must $ZFS allow $user create $basevol
1431 - user_run $user $ZFS clone $snap $clone
1432 - log_must $ZFS unallow $user create $basevol
1433 - log_must $ZFS unallow $user mount $basevol
1429 + log_must zfs allow $user mount $basevol
1430 + log_must zfs allow $user create $basevol
1431 + user_run $user zfs clone $snap $clone
1432 + log_must zfs unallow $user create $basevol
1433 + log_must zfs unallow $user mount $basevol
1434 1434 if ! datasetexists $clone ; then
1435 1435 return 1
1436 1436 fi
1437 1437
1438 1438 return 0
1439 1439 }
1440 1440
1441 1441 function verify_vol_rename
1442 1442 {
1443 1443 typeset user=$1
1444 1444 typeset perm=$2
1445 1445 typeset vol=$3
1446 1446
1447 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1447 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1448 1448 typeset basevol=${vol%/*}
1449 1449 typeset snap=$vol@snap.$stamp
1450 1450 typeset clone=$basevol/cvol.$stamp
1451 1451 typeset renamevol=$basevol/nvol.$stamp
1452 1452
1453 - user_run $user $ZFS rename $vol $renamevol
1453 + user_run $user zfs rename $vol $renamevol
1454 1454 if datasetexists $renamevol ; then
1455 1455 return 1
1456 1456 fi
1457 1457
1458 - log_must $ZFS allow $user create $basevol
1459 - user_run $user $ZFS rename $vol $renamevol
1460 - log_must $ZFS unallow $user create $basevol
1458 + log_must zfs allow $user create $basevol
1459 + user_run $user zfs rename $vol $renamevol
1460 + log_must zfs unallow $user create $basevol
1461 1461 if datasetexists $renamevol ; then
1462 1462 return 1
1463 1463 fi
1464 1464
1465 - log_must $ZFS allow $user mount $basevol
1466 - user_run $user $ZFS rename $vol $renamevol
1467 - log_must $ZFS unallow $user mount $basevol
1465 + log_must zfs allow $user mount $basevol
1466 + user_run $user zfs rename $vol $renamevol
1467 + log_must zfs unallow $user mount $basevol
1468 1468 if datasetexists $renamevol ; then
1469 1469 return 1
1470 1470 fi
1471 1471
1472 1472 # require both create permission on parent and
1473 1473 # mount permission on parent as well
1474 - log_must $ZFS allow $user mount $basevol
1475 - log_must $ZFS allow $user create $basevol
1476 - user_run $user $ZFS rename $vol $renamevol
1477 - log_must $ZFS unallow $user mount $basevol
1478 - log_must $ZFS unallow $user create $basevol
1474 + log_must zfs allow $user mount $basevol
1475 + log_must zfs allow $user create $basevol
1476 + user_run $user zfs rename $vol $renamevol
1477 + log_must zfs unallow $user mount $basevol
1478 + log_must zfs unallow $user create $basevol
1479 1479 if ! datasetexists $renamevol ; then
1480 1480 return 1
1481 1481 fi
1482 1482
1483 - log_must $ZFS rename $renamevol $vol
1483 + log_must zfs rename $renamevol $vol
1484 1484
1485 1485 return 0
1486 1486 }
1487 1487
1488 1488 function verify_vol_promote
1489 1489 {
1490 1490 typeset user=$1
1491 1491 typeset perm=$2
1492 1492 typeset vol=$3
1493 1493
1494 - typeset stamp=${perm}.${user}.$($DATE +'%F-%H%M%S')
1494 + typeset stamp=${perm}.${user}.$(date +'%F-%H%M%S')
1495 1495 typeset basevol=${vol%/*}
1496 1496 typeset snap=$vol@snap.$stamp
1497 1497 typeset clone=$basevol/cvol.$stamp
1498 1498
1499 - log_must $ZFS snapshot $snap
1500 - log_must $ZFS clone $snap $clone
1501 - log_must $ZFS promote $clone
1499 + log_must zfs snapshot $snap
1500 + log_must zfs clone $snap $clone
1501 + log_must zfs promote $clone
1502 1502
1503 1503 typeset vol_orig=$(get_prop origin $vol)
1504 1504 typeset clone_orig=$(get_prop origin $clone)
1505 1505
1506 1506 # promote should fail if $vol and $clone
1507 1507 # miss either mount or promote permission
1508 1508 # case 1
1509 - user_run $user $ZFS promote $vol
1509 + user_run $user zfs promote $vol
1510 1510 if [[ $vol_orig != $(get_prop origin $vol) || \
1511 1511 $clone_orig != $(get_prop origin $clone) ]];
1512 1512 then
1513 1513 return 1
1514 1514 fi
1515 1515
1516 1516 # promote should fail if $vol and $clone
1517 1517 # miss either mount or promote permission
1518 1518 # case 2
1519 - log_must $ZFS allow $user promote $clone
1520 - user_run $user $ZFS promote $vol
1521 - log_must $ZFS unallow $user promote $clone
1519 + log_must zfs allow $user promote $clone
1520 + user_run $user zfs promote $vol
1521 + log_must zfs unallow $user promote $clone
1522 1522 if [[ $vol_orig != $(get_prop origin $vol) || \
1523 1523 $clone_orig != $(get_prop origin $clone) ]];
1524 1524 then
1525 1525 return 1
1526 1526 fi
1527 1527
1528 1528 # promote should fail if $vol and $clone
1529 1529 # miss either mount or promote permission
1530 1530 # case 3
1531 - log_must $ZFS allow $user mount $vol
1532 - user_run $user $ZFS promote $vol
1533 - log_must $ZFS unallow $user mount $vol
1531 + log_must zfs allow $user mount $vol
1532 + user_run $user zfs promote $vol
1533 + log_must zfs unallow $user mount $vol
1534 1534 if [[ $vol_orig != $(get_prop origin $vol) || \
1535 1535 $clone_orig != $(get_prop origin $clone) ]];
1536 1536 then
1537 1537 return 1
1538 1538 fi
1539 1539
1540 1540 # promote should fail if $vol and $clone
1541 1541 # miss either mount or promote permission
1542 1542 # case 4
1543 - log_must $ZFS allow $user mount $clone
1544 - user_run $user $ZFS promote $vol
1545 - log_must $ZFS unallow $user mount $clone
1543 + log_must zfs allow $user mount $clone
1544 + user_run $user zfs promote $vol
1545 + log_must zfs unallow $user mount $clone
1546 1546 if [[ $vol_orig != $(get_prop origin $vol) || \
1547 1547 $clone_orig != $(get_prop origin $clone) ]];
1548 1548 then
1549 1549 return 1
1550 1550 fi
1551 1551
1552 1552 # promote should fail if $vol and $clone
1553 1553 # miss either mount or promote permission
1554 1554 # case 5
1555 - log_must $ZFS allow $user promote $clone
1556 - log_must $ZFS allow $user mount $vol
1557 - user_run $user $ZFS promote $vol
1558 - log_must $ZFS unallow $user promote $clone
1559 - log_must $ZFS unallow $user mount $vol
1555 + log_must zfs allow $user promote $clone
1556 + log_must zfs allow $user mount $vol
1557 + user_run $user zfs promote $vol
1558 + log_must zfs unallow $user promote $clone
1559 + log_must zfs unallow $user mount $vol
1560 1560 if [[ $vol_orig != $(get_prop origin $vol) || \
1561 1561 $clone_orig != $(get_prop origin $clone) ]];
1562 1562 then
1563 1563 return 1
1564 1564 fi
1565 1565
1566 1566 # promote should fail if $vol and $clone
1567 1567 # miss either mount or promote permission
1568 1568 # case 6
1569 - log_must $ZFS allow $user promote $clone
1570 - log_must $ZFS allow $user mount $clone
1571 - user_run $user $ZFS promote $vol
1572 - log_must $ZFS unallow $user promote $clone
1573 - log_must $ZFS unallow $user mount $vol
1569 + log_must zfs allow $user promote $clone
1570 + log_must zfs allow $user mount $clone
1571 + user_run $user zfs promote $vol
1572 + log_must zfs unallow $user promote $clone
1573 + log_must zfs unallow $user mount $vol
1574 1574 if [[ $vol_orig != $(get_prop origin $vol) || \
1575 1575 $clone_orig != $(get_prop origin $clone) ]];
1576 1576 then
1577 1577 return 1
1578 1578 fi
1579 1579
1580 1580 # promote should fail if $vol and $clone
1581 1581 # miss either mount or promote permission
1582 1582 # case 7
1583 - log_must $ZFS allow $user mount $vol
1584 - log_must $ZFS allow $user mount $clone
1585 - user_run $user $ZFS promote $vol
1586 - log_must $ZFS unallow $user mount $vol
1587 - log_must $ZFS unallow $user mount $clone
1583 + log_must zfs allow $user mount $vol
1584 + log_must zfs allow $user mount $clone
1585 + user_run $user zfs promote $vol
1586 + log_must zfs unallow $user mount $vol
1587 + log_must zfs unallow $user mount $clone
1588 1588 if [[ $vol_orig != $(get_prop origin $vol) || \
1589 1589 $clone_orig != $(get_prop origin $clone) ]];
1590 1590 then
1591 1591 return 1
1592 1592 fi
1593 1593
1594 1594 # promote only succeeds when $vol and $clone
1595 1595 # have both mount and promote permission
1596 1596 # case 8
1597 - log_must $ZFS allow $user promote $clone
1598 - log_must $ZFS allow $user mount $vol
1599 - log_must $ZFS allow $user mount $clone
1600 - user_run $user $ZFS promote $vol
1601 - log_must $ZFS unallow $user promote $clone
1602 - log_must $ZFS unallow $user mount $vol
1603 - log_must $ZFS unallow $user mount $clone
1597 + log_must zfs allow $user promote $clone
1598 + log_must zfs allow $user mount $vol
1599 + log_must zfs allow $user mount $clone
1600 + user_run $user zfs promote $vol
1601 + log_must zfs unallow $user promote $clone
1602 + log_must zfs unallow $user mount $vol
1603 + log_must zfs unallow $user mount $clone
1604 1604 if [[ $snap != $(get_prop origin $clone) || \
1605 1605 $clone_orig != $(get_prop origin $vol) ]]; then
1606 1606 return 1
1607 1607 fi
1608 1608
1609 1609 return 0
1610 1610 }
1611 1611
1612 1612 function verify_vol_volsize
1613 1613 {
1614 1614 typeset user=$1
1615 1615 typeset perm=$2
|
↓ open down ↓ |
2 lines elided |
↑ open up ↑ |
1616 1616 typeset vol=$3
1617 1617
1618 1618 typeset oldval
1619 1619 oldval=$(get_prop volsize $vol)
1620 1620 (( newval = oldval * 2 ))
1621 1621
1622 1622 reserv_size=$(get_prop refreservation $vol)
1623 1623
1624 1624 if [[ "0" == $reserv_size ]]; then
1625 1625 # sparse volume
1626 - user_run $user $ZFS set volsize=$newval $vol
1626 + user_run $user zfs set volsize=$newval $vol
1627 1627 if [[ $oldval == $(get_prop volsize $vol) ]];
1628 1628 then
1629 1629 return 1
1630 1630 fi
1631 1631
1632 1632 else
1633 1633 # normal volume, reservation permission
1634 1634 # is required
1635 - user_run $user $ZFS set volsize=$newval $vol
1635 + user_run $user zfs set volsize=$newval $vol
1636 1636 if [[ $newval == $(get_prop volsize $vol) ]];
1637 1637 then
1638 1638 return 1
1639 1639 fi
1640 1640
1641 - log_must $ZFS allow $user reservation $vol
1642 - log_must $ZFS allow $user refreservation $vol
1643 - user_run $user $ZFS set volsize=$newval $vol
1644 - log_must $ZFS unallow $user reservation $vol
1645 - log_must $ZFS unallow $user refreservation $vol
1641 + log_must zfs allow $user reservation $vol
1642 + log_must zfs allow $user refreservation $vol
1643 + user_run $user zfs set volsize=$newval $vol
1644 + log_must zfs unallow $user reservation $vol
1645 + log_must zfs unallow $user refreservation $vol
1646 1646 if [[ $oldval == $(get_prop volsize $vol) ]];
1647 1647 then
1648 1648 return 1
1649 1649 fi
1650 1650 fi
1651 1651
1652 1652 return 0
1653 1653 }
1654 1654
1655 1655 function verify_allow
1656 1656 {
1657 1657 typeset user=$1
1658 1658 typeset perm=$2
1659 1659 typeset dtst=$3
1660 1660
1661 1661 typeset -i ret
1662 1662
1663 - user_run $user $ZFS allow $user allow $dtst
1663 + user_run $user zfs allow $user allow $dtst
1664 1664 ret=$?
1665 1665 if [[ $ret -eq 0 ]]; then
1666 1666 return 1
1667 1667 fi
1668 1668
1669 - log_must $ZFS allow $user copies $dtst
1670 - user_run $user $ZFS allow $user copies $dtst
1669 + log_must zfs allow $user copies $dtst
1670 + user_run $user zfs allow $user copies $dtst
1671 1671 ret=$?
1672 - log_must $ZFS unallow $user copies $dtst
1672 + log_must zfs unallow $user copies $dtst
1673 1673 if [[ $ret -eq 1 ]]; then
1674 1674 return 1
1675 1675 fi
1676 1676
1677 1677 return 0
1678 1678
1679 1679 }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX