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