tests/zfs-tests/tests/functional/delegate/delegate_common.kshlib

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