tests/zfs-tests/include/libtest.shlib

   1 #!/bin/ksh -p
   2 #
   3 # CDDL HEADER START
   4 #
   5 # The contents of this file are subject to the terms of the
   6 # Common Development and Distribution License (the "License").
   7 # You may not use this file except in compliance with the License.
   8 #
   9 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10 # or http://www.opensolaris.org/os/licensing.
  11 # See the License for the specific language governing permissions
  12 # and limitations under the License.
  13 #
  14 # When distributing Covered Code, include this CDDL HEADER in each
  15 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16 # If applicable, add the following below this CDDL HEADER, with the
  17 # fields enclosed by brackets "[]" replaced with your own identifying
  18 # information: Portions Copyright [yyyy] [name of copyright owner]
  19 #
  20 # CDDL HEADER END
  21 #
  22
  23 #
  24 # Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  25 # Use is subject to license terms.
  26 # Copyright (c) 2012, 2016 by Delphix. All rights reserved.
  27 # Copyright 2016 Nexenta Systems, Inc.
  28 # Copyright (c) 2017 Lawrence Livermore National Security, LLC.
  29 # Copyright (c) 2017 Datto Inc.
  30 # Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
  31 #
  32
  33 . ${STF_TOOLS}/include/logapi.shlib
  34 . ${STF_SUITE}/include/math.shlib
  35 . ${STF_SUITE}/include/blkdev.shlib
  36
  37 #
  38 # Apply constrained path when available.  This is required since the
  39 # PATH may have been modified by sudo's secure_path behavior.
  40 #
  41 if [ -n "$STF_PATH" ]; then
  42         PATH="$STF_PATH"
  43 fi
  44
  45 # Linux kernel version comparison function
  46 #
  47 # $1 Linux version ("4.10", "2.6.32") or blank for installed Linux version
  48 #
  49 # Used for comparison: if [ $(linux_version) -ge $(linux_version "2.6.32") ]
  50 #
  51 function linux_version
  52 {
  53         typeset ver="$1"
  54
  55         [[ -z "$ver" ]] && ver=$(uname -r | grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+")
  56
  57         typeset version=$(echo $ver | cut -d '.' -f 1)
  58         typeset major=$(echo $ver | cut -d '.' -f 2)
  59         typeset minor=$(echo $ver | cut -d '.' -f 3)
  60
  61         [[ -z "$version" ]] && version=0
  62         [[ -z "$major" ]] && major=0
  63         [[ -z "$minor" ]] && minor=0
  64
  65         echo $((version * 10000 + major * 100 + minor))
  66 }
  67
  68 # Determine if this is a Linux test system
  69 #
  70 # Return 0 if platform Linux, 1 if otherwise
  71
  72 function is_linux
  73 {
  74         if [[ $(uname -o) == "GNU/Linux" ]]; then
  75                 return 0
  76         else
  77                 return 1
  78         fi
  79 }
  80
  81 # Determine if this is a 32-bit system
  82 #
  83 # Return 0 if platform is 32-bit, 1 if otherwise
  84
  85 function is_32bit
  86 {
  87         if [[ $(getconf LONG_BIT) == "32" ]]; then
  88                 return 0
  89         else
  90                 return 1
  91         fi
  92 }
  93
  94 # Determine if kmemleak is enabled
  95 #
  96 # Return 0 if kmemleak is enabled, 1 if otherwise
  97
  98 function is_kmemleak
  99 {
 100         if is_linux && [[ -e /sys/kernel/debug/kmemleak ]]; then
 101                 return 0
 102         else
 103                 return 1
 104         fi
 105 }
 106
 107 # Determine whether a dataset is mounted
 108 #
 109 # $1 dataset name
 110 # $2 filesystem type; optional - defaulted to zfs
 111 #
 112 # Return 0 if dataset is mounted; 1 if unmounted; 2 on error
 113
 114 function ismounted
 115 {
 116         typeset fstype=$2
 117         [[ -z $fstype ]] && fstype=zfs
 118         typeset out dir name ret
 119
 120         case $fstype in
 121                 zfs)
 122                         if [[ "$1" == "/"* ]] ; then
 123                                 for out in $(zfs mount | awk '{print $2}'); do
 124                                         [[ $1 == $out ]] && return 0
 125                                 done
 126                         else
 127                                 for out in $(zfs mount | awk '{print $1}'); do
 128                                         [[ $1 == $out ]] && return 0
 129                                 done
 130                         fi
 131                 ;;
 132                 ufs|nfs)
 133                         out=$(df -F $fstype $1 2>/dev/null)
 134                         ret=$?
 135                         (($ret != 0)) && return $ret
 136
 137                         dir=${out%%\(*}
 138                         dir=${dir%% *}
 139                         name=${out##*\(}
 140                         name=${name%%\)*}
 141                         name=${name%% *}
 142
 143                         [[ "$1" == "$dir" || "$1" == "$name" ]] && return 0
 144                 ;;
 145                 ext*)
 146                         out=$(df -t $fstype $1 2>/dev/null)
 147                         return $?
 148                 ;;
 149                 zvol)
 150                         if [[ -L "$ZVOL_DEVDIR/$1" ]]; then
 151                                 link=$(readlink -f $ZVOL_DEVDIR/$1)
 152                                 [[ -n "$link" ]] && \
 153                                         mount | grep -q "^$link" && \
 154                                                 return 0
 155                         fi
 156                 ;;
 157         esac
 158
 159         return 1
 160 }
 161
 162 # Return 0 if a dataset is mounted; 1 otherwise
 163 #
 164 # $1 dataset name
 165 # $2 filesystem type; optional - defaulted to zfs
 166
 167 function mounted
 168 {
 169         ismounted $1 $2
 170         (($? == 0)) && return 0
 171         return 1
 172 }
 173
 174 # Return 0 if a dataset is unmounted; 1 otherwise
 175 #
 176 # $1 dataset name
 177 # $2 filesystem type; optional - defaulted to zfs
 178
 179 function unmounted
 180 {
 181         ismounted $1 $2
 182         (($? == 1)) && return 0
 183         return 1
 184 }
 185
 186 # split line on ","
 187 #
 188 # $1 - line to split
 189
 190 function splitline
 191 {
 192         echo $1 | sed "s/,/ /g"
 193 }
 194
 195 function default_setup
 196 {
 197         default_setup_noexit "$@"
 198
 199         log_pass
 200 }
 201
 202 #
 203 # Given a list of disks, setup storage pools and datasets.
 204 #
 205 function default_setup_noexit
 206 {
 207         typeset disklist=$1
 208         typeset container=$2
 209         typeset volume=$3
 210         log_note begin default_setup_noexit
 211
 212         if is_global_zone; then
 213                 if poolexists $TESTPOOL ; then
 214                         destroy_pool $TESTPOOL
 215                 fi
 216                 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
 217                 log_must zpool create -f $TESTPOOL $disklist
 218         else
 219                 reexport_pool
 220         fi
 221
 222         rm -rf $TESTDIR  || log_unresolved Could not remove $TESTDIR
 223         mkdir -p $TESTDIR || log_unresolved Could not create $TESTDIR
 224
 225         log_must zfs create $TESTPOOL/$TESTFS
 226         log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
 227
 228         if [[ -n $container ]]; then
 229                 rm -rf $TESTDIR1  || \
 230                         log_unresolved Could not remove $TESTDIR1
 231                 mkdir -p $TESTDIR1 || \
 232                         log_unresolved Could not create $TESTDIR1
 233
 234                 log_must zfs create $TESTPOOL/$TESTCTR
 235                 log_must zfs set canmount=off $TESTPOOL/$TESTCTR
 236                 log_must zfs create $TESTPOOL/$TESTCTR/$TESTFS1
 237                 log_must zfs set mountpoint=$TESTDIR1 \
 238                     $TESTPOOL/$TESTCTR/$TESTFS1
 239         fi
 240
 241         if [[ -n $volume ]]; then
 242                 if is_global_zone ; then
 243                         log_must zfs create -V $VOLSIZE $TESTPOOL/$TESTVOL
 244                         block_device_wait
 245                 else
 246                         log_must zfs create $TESTPOOL/$TESTVOL
 247                 fi
 248         fi
 249 }
 250
 251 #
 252 # Given a list of disks, setup a storage pool, file system and
 253 # a container.
 254 #
 255 function default_container_setup
 256 {
 257         typeset disklist=$1
 258
 259         default_setup "$disklist" "true"
 260 }
 261
 262 #
 263 # Given a list of disks, setup a storage pool,file system
 264 # and a volume.
 265 #
 266 function default_volume_setup
 267 {
 268         typeset disklist=$1
 269
 270         default_setup "$disklist" "" "true"
 271 }
 272
 273 #
 274 # Given a list of disks, setup a storage pool,file system,
 275 # a container and a volume.
 276 #
 277 function default_container_volume_setup
 278 {
 279         typeset disklist=$1
 280
 281         default_setup "$disklist" "true" "true"
 282 }
 283
 284 #
 285 # Create a snapshot on a filesystem or volume. Defaultly create a snapshot on
 286 # filesystem
 287 #
 288 # $1 Existing filesystem or volume name. Default, $TESTPOOL/$TESTFS
 289 # $2 snapshot name. Default, $TESTSNAP
 290 #
 291 function create_snapshot
 292 {
 293         typeset fs_vol=${1:-$TESTPOOL/$TESTFS}
 294         typeset snap=${2:-$TESTSNAP}
 295
 296         [[ -z $fs_vol ]] && log_fail "Filesystem or volume's name is undefined."
 297         [[ -z $snap ]] && log_fail "Snapshot's name is undefined."
 298
 299         if snapexists $fs_vol@$snap; then
 300                 log_fail "$fs_vol@$snap already exists."
 301         fi
 302         datasetexists $fs_vol || \
 303                 log_fail "$fs_vol must exist."
 304
 305         log_must zfs snapshot $fs_vol@$snap
 306 }
 307
 308 #
 309 # Create a clone from a snapshot, default clone name is $TESTCLONE.
 310 #
 311 # $1 Existing snapshot, $TESTPOOL/$TESTFS@$TESTSNAP is default.
 312 # $2 Clone name, $TESTPOOL/$TESTCLONE is default.
 313 #
 314 function create_clone   # snapshot clone
 315 {
 316         typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
 317         typeset clone=${2:-$TESTPOOL/$TESTCLONE}
 318
 319         [[ -z $snap ]] && \
 320                 log_fail "Snapshot name is undefined."
 321         [[ -z $clone ]] && \
 322                 log_fail "Clone name is undefined."
 323
 324         log_must zfs clone $snap $clone
 325 }
 326
 327 #
 328 # Create a bookmark of the given snapshot.  Defaultly create a bookmark on
 329 # filesystem.
 330 #
 331 # $1 Existing filesystem or volume name. Default, $TESTFS
 332 # $2 Existing snapshot name. Default, $TESTSNAP
 333 # $3 bookmark name. Default, $TESTBKMARK
 334 #
 335 function create_bookmark
 336 {
 337         typeset fs_vol=${1:-$TESTFS}
 338         typeset snap=${2:-$TESTSNAP}
 339         typeset bkmark=${3:-$TESTBKMARK}
 340
 341         [[ -z $fs_vol ]] && log_fail "Filesystem or volume's name is undefined."
 342         [[ -z $snap ]] && log_fail "Snapshot's name is undefined."
 343         [[ -z $bkmark ]] && log_fail "Bookmark's name is undefined."
 344
 345         if bkmarkexists $fs_vol#$bkmark; then
 346                 log_fail "$fs_vol#$bkmark already exists."
 347         fi
 348         datasetexists $fs_vol || \
 349                 log_fail "$fs_vol must exist."
 350         snapexists $fs_vol@$snap || \
 351                 log_fail "$fs_vol@$snap must exist."
 352
 353         log_must zfs bookmark $fs_vol@$snap $fs_vol#$bkmark
 354 }
 355
 356 #
 357 # Create a temporary clone result of an interrupted resumable 'zfs receive'
 358 # $1 Destination filesystem name. Must not exist, will be created as the result
 359 #    of this function along with its %recv temporary clone
 360 # $2 Source filesystem name. Must not exist, will be created and destroyed
 361 #
 362 function create_recv_clone
 363 {
 364         typeset recvfs="$1"
 365         typeset sendfs="${2:-$TESTPOOL/create_recv_clone}"
 366         typeset snap="$sendfs@snap1"
 367         typeset incr="$sendfs@snap2"
 368         typeset mountpoint="$TESTDIR/create_recv_clone"
 369         typeset sendfile="$TESTDIR/create_recv_clone.zsnap"
 370
 371         [[ -z $recvfs ]] && log_fail "Recv filesystem's name is undefined."
 372
 373         datasetexists $recvfs && log_fail "Recv filesystem must not exist."
 374         datasetexists $sendfs && log_fail "Send filesystem must not exist."
 375
 376         log_must zfs create -o mountpoint="$mountpoint" $sendfs
 377         log_must zfs snapshot $snap
 378         log_must eval "zfs send $snap | zfs recv -u $recvfs"
 379         log_must mkfile 1m "$mountpoint/data"
 380         log_must zfs snapshot $incr
 381         log_must eval "zfs send -i $snap $incr | dd bs=10K count=1 > $sendfile"
 382         log_mustnot eval "zfs recv -su $recvfs < $sendfile"
 383         log_must zfs destroy -r $sendfs
 384         log_must rm -f "$sendfile"
 385
 386         if [[ $(get_prop 'inconsistent' "$recvfs/%recv") -ne 1 ]]; then
 387                 log_fail "Error creating temporary $recvfs/%recv clone"
 388         fi
 389 }
 390
 391 function default_mirror_setup
 392 {
 393         default_mirror_setup_noexit $1 $2 $3
 394
 395         log_pass
 396 }
 397
 398 #
 399 # Given a pair of disks, set up a storage pool and dataset for the mirror
 400 # @parameters: $1 the primary side of the mirror
 401 #   $2 the secondary side of the mirror
 402 # @uses: ZPOOL ZFS TESTPOOL TESTFS
 403 function default_mirror_setup_noexit
 404 {
 405         readonly func="default_mirror_setup_noexit"
 406         typeset primary=$1
 407         typeset secondary=$2
 408
 409         [[ -z $primary ]] && \
 410                 log_fail "$func: No parameters passed"
 411         [[ -z $secondary ]] && \
 412                 log_fail "$func: No secondary partition passed"
 413         [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
 414         log_must zpool create -f $TESTPOOL mirror $@
 415         log_must zfs create $TESTPOOL/$TESTFS
 416         log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
 417 }
 418
 419 #
 420 # create a number of mirrors.
 421 # We create a number($1) of 2 way mirrors using the pairs of disks named
 422 # on the command line. These mirrors are *not* mounted
 423 # @parameters: $1 the number of mirrors to create
 424 #  $... the devices to use to create the mirrors on
 425 # @uses: ZPOOL ZFS TESTPOOL
 426 function setup_mirrors
 427 {
 428         typeset -i nmirrors=$1
 429
 430         shift
 431         while ((nmirrors > 0)); do
 432                 log_must test -n "$1" -a -n "$2"
 433                 [[ -d /$TESTPOOL$nmirrors ]] && rm -rf /$TESTPOOL$nmirrors
 434                 log_must zpool create -f $TESTPOOL$nmirrors mirror $1 $2
 435                 shift 2
 436                 ((nmirrors = nmirrors - 1))
 437         done
 438 }
 439
 440 #
 441 # create a number of raidz pools.
 442 # We create a number($1) of 2 raidz pools  using the pairs of disks named
 443 # on the command line. These pools are *not* mounted
 444 # @parameters: $1 the number of pools to create
 445 #  $... the devices to use to create the pools on
 446 # @uses: ZPOOL ZFS TESTPOOL
 447 function setup_raidzs
 448 {
 449         typeset -i nraidzs=$1
 450
 451         shift
 452         while ((nraidzs > 0)); do
 453                 log_must test -n "$1" -a -n "$2"
 454                 [[ -d /$TESTPOOL$nraidzs ]] && rm -rf /$TESTPOOL$nraidzs
 455                 log_must zpool create -f $TESTPOOL$nraidzs raidz $1 $2
 456                 shift 2
 457                 ((nraidzs = nraidzs - 1))
 458         done
 459 }
 460
 461 #
 462 # Destroy the configured testpool mirrors.
 463 # the mirrors are of the form ${TESTPOOL}{number}
 464 # @uses: ZPOOL ZFS TESTPOOL
 465 function destroy_mirrors
 466 {
 467         default_cleanup_noexit
 468
 469         log_pass
 470 }
 471
 472 #
 473 # Given a minimum of two disks, set up a storage pool and dataset for the raid-z
 474 # $1 the list of disks
 475 #
 476 function default_raidz_setup
 477 {
 478         typeset disklist="$*"
 479         disks=(${disklist[*]})
 480
 481         if [[ ${#disks[*]} -lt 2 ]]; then
 482                 log_fail "A raid-z requires a minimum of two disks."
 483         fi
 484
 485         [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
 486         log_must zpool create -f $TESTPOOL raidz $disklist
 487         log_must zfs create $TESTPOOL/$TESTFS
 488         log_must zfs set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
 489
 490         log_pass
 491 }
 492
 493 #
 494 # Common function used to cleanup storage pools and datasets.
 495 #
 496 # Invoked at the start of the test suite to ensure the system
 497 # is in a known state, and also at the end of each set of
 498 # sub-tests to ensure errors from one set of tests doesn't
 499 # impact the execution of the next set.
 500
 501 function default_cleanup
 502 {
 503         default_cleanup_noexit
 504
 505         log_pass
 506 }
 507
 508 #
 509 # Utility function used to list all available pool names.
 510 #
 511 # NOTE: $KEEP is a variable containing pool names, separated by a newline
 512 # character, that must be excluded from the returned list.
 513 #
 514 function get_all_pools
 515 {
 516         zpool list -H -o name | grep -Fvx "$KEEP" | grep -v "$NO_POOLS"
 517 }
 518
 519 function default_cleanup_noexit
 520 {
 521         typeset pool=""
 522         #
 523         # Destroying the pool will also destroy any
 524         # filesystems it contains.
 525         #
 526         if is_global_zone; then
 527                 zfs unmount -a > /dev/null 2>&1
 528                 ALL_POOLS=$(get_all_pools)
 529                 # Here, we loop through the pools we're allowed to
 530                 # destroy, only destroying them if it's safe to do
 531                 # so.
 532                 while [ ! -z ${ALL_POOLS} ]
 533                 do
 534                         for pool in ${ALL_POOLS}
 535                         do
 536                                 if safe_to_destroy_pool $pool ;
 537                                 then
 538                                         destroy_pool $pool
 539                                 fi
 540                                 ALL_POOLS=$(get_all_pools)
 541                         done
 542                 done
 543
 544                 zfs mount -a
 545         else
 546                 typeset fs=""
 547                 for fs in $(zfs list -H -o name \
 548                     | grep "^$ZONE_POOL/$ZONE_CTR[01234]/"); do
 549                         datasetexists $fs && \
 550                                 log_must zfs destroy -Rf $fs
 551                 done
 552
 553                 # Need cleanup here to avoid garbage dir left.
 554                 for fs in $(zfs list -H -o name); do
 555                         [[ $fs == /$ZONE_POOL ]] && continue
 556                         [[ -d $fs ]] && log_must rm -rf $fs/*
 557                 done
 558
 559                 #
 560                 # Reset the $ZONE_POOL/$ZONE_CTR[01234] file systems property to
 561                 # the default value
 562                 #
 563                 for fs in $(zfs list -H -o name); do
 564                         if [[ $fs == $ZONE_POOL/$ZONE_CTR[01234] ]]; then
 565                                 log_must zfs set reservation=none $fs
 566                                 log_must zfs set recordsize=128K $fs
 567                                 log_must zfs set mountpoint=/$fs $fs
 568                                 typeset enc=""
 569                                 enc=$(get_prop encryption $fs)
 570                                 if [[ $? -ne 0 ]] || [[ -z "$enc" ]] || \
 571                                         [[ "$enc" == "off" ]]; then
 572                                         log_must zfs set checksum=on $fs
 573                                 fi
 574                                 log_must zfs set compression=off $fs
 575                                 log_must zfs set atime=on $fs
 576                                 log_must zfs set devices=off $fs
 577                                 log_must zfs set exec=on $fs
 578                                 log_must zfs set setuid=on $fs
 579                                 log_must zfs set readonly=off $fs
 580                                 log_must zfs set snapdir=hidden $fs
 581                                 log_must zfs set aclmode=groupmask $fs
 582                                 log_must zfs set aclinherit=secure $fs
 583                         fi
 584                 done
 585         fi
 586
 587         [[ -d $TESTDIR ]] && \
 588                 log_must rm -rf $TESTDIR
 589
 590         disk1=${DISKS%% *}
 591         if is_mpath_device $disk1; then
 592                 delete_partitions
 593         fi
 594 }
 595
 596
 597 #
 598 # Common function used to cleanup storage pools, file systems
 599 # and containers.
 600 #
 601 function default_container_cleanup
 602 {
 603         if ! is_global_zone; then
 604                 reexport_pool
 605         fi
 606
 607         ismounted $TESTPOOL/$TESTCTR/$TESTFS1
 608         [[ $? -eq 0 ]] && \
 609             log_must zfs unmount $TESTPOOL/$TESTCTR/$TESTFS1
 610
 611         datasetexists $TESTPOOL/$TESTCTR/$TESTFS1 && \
 612             log_must zfs destroy -R $TESTPOOL/$TESTCTR/$TESTFS1
 613
 614         datasetexists $TESTPOOL/$TESTCTR && \
 615             log_must zfs destroy -Rf $TESTPOOL/$TESTCTR
 616
 617         [[ -e $TESTDIR1 ]] && \
 618             log_must rm -rf $TESTDIR1 > /dev/null 2>&1
 619
 620         default_cleanup
 621 }
 622
 623 #
 624 # Common function used to cleanup snapshot of file system or volume. Default to
 625 # delete the file system's snapshot
 626 #
 627 # $1 snapshot name
 628 #
 629 function destroy_snapshot
 630 {
 631         typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
 632
 633         if ! snapexists $snap; then
 634                 log_fail "'$snap' does not existed."
 635         fi
 636
 637         #
 638         # For the sake of the value which come from 'get_prop' is not equal
 639         # to the really mountpoint when the snapshot is unmounted. So, firstly
 640         # check and make sure this snapshot's been mounted in current system.
 641         #
 642         typeset mtpt=""
 643         if ismounted $snap; then
 644                 mtpt=$(get_prop mountpoint $snap)
 645                 (($? != 0)) && \
 646                         log_fail "get_prop mountpoint $snap failed."
 647         fi
 648
 649         log_must zfs destroy $snap
 650         [[ $mtpt != "" && -d $mtpt ]] && \
 651                 log_must rm -rf $mtpt
 652 }
 653
 654 #
 655 # Common function used to cleanup clone.
 656 #
 657 # $1 clone name
 658 #
 659 function destroy_clone
 660 {
 661         typeset clone=${1:-$TESTPOOL/$TESTCLONE}
 662
 663         if ! datasetexists $clone; then
 664                 log_fail "'$clone' does not existed."
 665         fi
 666
 667         # With the same reason in destroy_snapshot
 668         typeset mtpt=""
 669         if ismounted $clone; then
 670                 mtpt=$(get_prop mountpoint $clone)
 671                 (($? != 0)) && \
 672                         log_fail "get_prop mountpoint $clone failed."
 673         fi
 674
 675         log_must zfs destroy $clone
 676         [[ $mtpt != "" && -d $mtpt ]] && \
 677                 log_must rm -rf $mtpt
 678 }
 679
 680 #
 681 # Common function used to cleanup bookmark of file system or volume.  Default
 682 # to delete the file system's bookmark.
 683 #
 684 # $1 bookmark name
 685 #
 686 function destroy_bookmark
 687 {
 688         typeset bkmark=${1:-$TESTPOOL/$TESTFS#$TESTBKMARK}
 689
 690         if ! bkmarkexists $bkmark; then
 691                 log_fail "'$bkmarkp' does not existed."
 692         fi
 693
 694         log_must zfs destroy $bkmark
 695 }
 696
 697 # Return 0 if a snapshot exists; $? otherwise
 698 #
 699 # $1 - snapshot name
 700
 701 function snapexists
 702 {
 703         zfs list -H -t snapshot "$1" > /dev/null 2>&1
 704         return $?
 705 }
 706
 707 #
 708 # Return 0 if a bookmark exists; $? otherwise
 709 #
 710 # $1 - bookmark name
 711 #
 712 function bkmarkexists
 713 {
 714         zfs list -H -t bookmark "$1" > /dev/null 2>&1
 715         return $?
 716 }
 717
 718 #
 719 # Set a property to a certain value on a dataset.
 720 # Sets a property of the dataset to the value as passed in.
 721 # @param:
 722 #       $1 dataset who's property is being set
 723 #       $2 property to set
 724 #       $3 value to set property to
 725 # @return:
 726 #       0 if the property could be set.
 727 #       non-zero otherwise.
 728 # @use: ZFS
 729 #
 730 function dataset_setprop
 731 {
 732         typeset fn=dataset_setprop
 733
 734         if (($# < 3)); then
 735                 log_note "$fn: Insufficient parameters (need 3, had $#)"
 736                 return 1
 737         fi
 738         typeset output=
 739         output=$(zfs set $2=$3 $1 2>&1)
 740         typeset rv=$?
 741         if ((rv != 0)); then
 742                 log_note "Setting property on $1 failed."
 743                 log_note "property $2=$3"
 744                 log_note "Return Code: $rv"
 745                 log_note "Output: $output"
 746                 return $rv
 747         fi
 748         return 0
 749 }
 750
 751 #
 752 # Assign suite defined dataset properties.
 753 # This function is used to apply the suite's defined default set of
 754 # properties to a dataset.
 755 # @parameters: $1 dataset to use
 756 # @uses: ZFS COMPRESSION_PROP CHECKSUM_PROP
 757 # @returns:
 758 #   0 if the dataset has been altered.
 759 #   1 if no pool name was passed in.
 760 #   2 if the dataset could not be found.
 761 #   3 if the dataset could not have it's properties set.
 762 #
 763 function dataset_set_defaultproperties
 764 {
 765         typeset dataset="$1"
 766
 767         [[ -z $dataset ]] && return 1
 768
 769         typeset confset=
 770         typeset -i found=0
 771         for confset in $(zfs list); do
 772                 if [[ $dataset = $confset ]]; then
 773                         found=1
 774                         break
 775                 fi
 776         done
 777         [[ $found -eq 0 ]] && return 2
 778         if [[ -n $COMPRESSION_PROP ]]; then
 779                 dataset_setprop $dataset compression $COMPRESSION_PROP || \
 780                         return 3
 781                 log_note "Compression set to '$COMPRESSION_PROP' on $dataset"
 782         fi
 783         if [[ -n $CHECKSUM_PROP ]]; then
 784                 dataset_setprop $dataset checksum $CHECKSUM_PROP || \
 785                         return 3
 786                 log_note "Checksum set to '$CHECKSUM_PROP' on $dataset"
 787         fi
 788         return 0
 789 }
 790
 791 #
 792 # Check a numeric assertion
 793 # @parameter: $@ the assertion to check
 794 # @output: big loud notice if assertion failed
 795 # @use: log_fail
 796 #
 797 function assert
 798 {
 799         (($@)) || log_fail "$@"
 800 }
 801
 802 #
 803 # Function to format partition size of a disk
 804 # Given a disk cxtxdx reduces all partitions
 805 # to 0 size
 806 #
 807 function zero_partitions #<whole_disk_name>
 808 {
 809         typeset diskname=$1
 810         typeset i
 811
 812         if is_linux; then
 813                 log_must parted $DEV_DSKDIR/$diskname -s -- mklabel gpt
 814         else
 815                 for i in 0 1 3 4 5 6 7
 816                 do
 817                         log_must set_partition $i "" 0mb $diskname
 818                 done
 819         fi
 820
 821         return 0
 822 }
 823
 824 #
 825 # Given a slice, size and disk, this function
 826 # formats the slice to the specified size.
 827 # Size should be specified with units as per
 828 # the `format` command requirements eg. 100mb 3gb
 829 #
 830 # NOTE: This entire interface is problematic for the Linux parted utilty
 831 # which requires the end of the partition to be specified.  It would be
 832 # best to retire this interface and replace it with something more flexible.
 833 # At the moment a best effort is made.
 834 #
 835 function set_partition #<slice_num> <slice_start> <size_plus_units>  <whole_disk_name>
 836 {
 837         typeset -i slicenum=$1
 838         typeset start=$2
 839         typeset size=$3
 840         typeset disk=$4
 841         [[ -z $slicenum || -z $size || -z $disk ]] && \
 842             log_fail "The slice, size or disk name is unspecified."
 843
 844         if is_linux; then
 845                 typeset size_mb=${size%%[mMgG]}
 846
 847                 size_mb=${size_mb%%[mMgG][bB]}
 848                 if [[ ${size:1:1} == 'g' ]]; then
 849                         ((size_mb = size_mb * 1024))
 850                 fi
 851
 852                 # Create GPT partition table when setting slice 0 or
 853                 # when the device doesn't already contain a GPT label.
 854                 parted $DEV_DSKDIR/$disk -s -- print 1 >/dev/null
 855                 typeset ret_val=$?
 856                 if [[ $slicenum -eq 0 || $ret_val -ne 0 ]]; then
 857                         parted $DEV_DSKDIR/$disk -s -- mklabel gpt
 858                         if [[ $? -ne 0 ]]; then
 859                                 log_note "Failed to create GPT partition table on $disk"
 860                                 return 1
 861                         fi
 862                 fi
 863
 864                 # When no start is given align on the first cylinder.
 865                 if [[ -z "$start" ]]; then
 866                         start=1
 867                 fi
 868
 869                 # Determine the cylinder size for the device and using
 870                 # that calculate the end offset in cylinders.
 871                 typeset -i cly_size_kb=0
 872                 cly_size_kb=$(parted -m $DEV_DSKDIR/$disk -s -- \
 873                         unit cyl print | head -3 | tail -1 | \
 874                         awk -F '[:k.]' '{print $4}')
 875                 ((end = (size_mb * 1024 / cly_size_kb) + start))
 876
 877                 parted $DEV_DSKDIR/$disk -s -- \
 878                     mkpart part$slicenum ${start}cyl ${end}cyl
 879                 if [[ $? -ne 0 ]]; then
 880                         log_note "Failed to create partition $slicenum on $disk"
 881                         return 1
 882                 fi
 883
 884                 blockdev --rereadpt $DEV_DSKDIR/$disk 2>/dev/null
 885                 block_device_wait
 886         else
 887                 typeset format_file=/var/tmp/format_in.$$
 888
 889                 echo "partition" >$format_file
 890                 echo "$slicenum" >> $format_file
 891                 echo "" >> $format_file
 892                 echo "" >> $format_file
 893                 echo "$start" >> $format_file
 894                 echo "$size" >> $format_file
 895                 echo "label" >> $format_file
 896                 echo "" >> $format_file
 897                 echo "q" >> $format_file
 898                 echo "q" >> $format_file
 899
 900                 format -e -s -d $disk -f $format_file
 901         fi
 902
 903         typeset ret_val=$?
 904         rm -f $format_file
 905         if [[ $ret_val -ne 0 ]]; then
 906                 log_note "Unable to format $disk slice $slicenum to $size"
 907                 return 1
 908         fi
 909         return 0
 910 }
 911
 912 #
 913 # Delete all partitions on all disks - this is specifically for the use of multipath
 914 # devices which currently can only be used in the test suite as raw/un-partitioned
 915 # devices (ie a zpool cannot be created on a whole mpath device that has partitions)
 916 #
 917 function delete_partitions
 918 {
 919         typeset -i j=1
 920
 921         if [[ -z $DISK_ARRAY_NUM ]]; then
 922                 DISK_ARRAY_NUM=$(echo ${DISKS} | nawk '{print NF}')
 923         fi
 924         if [[ -z $DISKSARRAY ]]; then
 925                 DISKSARRAY=$DISKS
 926         fi
 927
 928         if is_linux; then
 929                 if (( $DISK_ARRAY_NUM == 1 )); then
 930                         while ((j < MAX_PARTITIONS)); do
 931                                 parted $DEV_DSKDIR/$DISK -s rm $j \
 932                                     > /dev/null 2>&1
 933                                 if (( $? == 1 )); then
 934                                         lsblk | egrep ${DISK}${SLICE_PREFIX}${j} > /dev/null
 935                                                 if (( $? == 1 )); then
 936                                                         log_note "Partitions for $DISK should be deleted"
 937                                                 else
 938                                                         log_fail "Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
 939                                                 fi
 940                                                 return 0
 941                                 else
 942                                         lsblk | egrep ${DISK}${SLICE_PREFIX}${j} > /dev/null
 943                                                 if (( $? == 0 )); then
 944                                                         log_fail "Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
 945                                                 fi
 946                                 fi
 947                                 ((j = j+1))
 948                         done
 949                 else
 950                         for disk in `echo $DISKSARRAY`; do
 951                                 while ((j < MAX_PARTITIONS)); do
 952                                         parted $DEV_DSKDIR/$disk -s rm $j > /dev/null 2>&1
 953                                         if (( $? == 1 )); then
 954                                                 lsblk | egrep ${disk}${SLICE_PREFIX}${j} > /dev/null
 955                                                 if (( $? == 1 )); then
 956                                                         log_note "Partitions for $disk should be deleted"
 957                                                 else
 958                                                         log_fail "Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
 959                                                 fi
 960                                                 j=7
 961                                         else
 962                                                 lsblk | egrep ${disk}${SLICE_PREFIX}${j} > /dev/null
 963                                                 if (( $? == 0 )); then
 964                                                         log_fail "Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
 965                                                 fi
 966                                         fi
 967                                         ((j = j+1))
 968                                 done
 969                                 j=1
 970                         done
 971                 fi
 972         fi
 973         return 0
 974 }
 975
 976 #
 977 # Get the end cyl of the given slice
 978 #
 979 function get_endslice #<disk> <slice>
 980 {
 981         typeset disk=$1
 982         typeset slice=$2
 983         if [[ -z $disk || -z $slice ]] ; then
 984                 log_fail "The disk name or slice number is unspecified."
 985         fi
 986
 987         if is_linux; then
 988                 endcyl=$(parted -s $DEV_DSKDIR/$disk -- unit cyl print | \
 989                         grep "part${slice}" | \
 990                         awk '{print $3}' | \
 991                         sed 's,cyl,,')
 992                 ((endcyl = (endcyl + 1)))
 993         else
 994                 disk=${disk#/dev/dsk/}
 995                 disk=${disk#/dev/rdsk/}
 996                 disk=${disk%s*}
 997
 998                 typeset -i ratio=0
 999                 ratio=$(prtvtoc /dev/rdsk/${disk}s2 | \
1000                     grep "sectors\/cylinder" | \
1001                     awk '{print $2}')
1002
1003                 if ((ratio == 0)); then
1004                         return
1005                 fi
1006
1007                 typeset -i endcyl=$(prtvtoc -h /dev/rdsk/${disk}s2 |
1008                     nawk -v token="$slice" '{if ($1==token) print $6}')
1009
1010                 ((endcyl = (endcyl + 1) / ratio))
1011         fi
1012
1013         echo $endcyl
1014 }
1015
1016
1017 #
1018 # Given a size,disk and total slice number,  this function formats the
1019 # disk slices from 0 to the total slice number with the same specified
1020 # size.
1021 #
1022 function partition_disk #<slice_size> <whole_disk_name> <total_slices>
1023 {
1024         typeset -i i=0
1025         typeset slice_size=$1
1026         typeset disk_name=$2
1027         typeset total_slices=$3
1028         typeset cyl
1029
1030         zero_partitions $disk_name
1031         while ((i < $total_slices)); do
1032                 if ! is_linux; then
1033                         if ((i == 2)); then
1034                                 ((i = i + 1))
1035                                 continue
1036                         fi
1037                 fi
1038                 log_must set_partition $i "$cyl" $slice_size $disk_name
1039                 cyl=$(get_endslice $disk_name $i)
1040                 ((i = i+1))
1041         done
1042 }
1043
1044 #
1045 # This function continues to write to a filenum number of files into dirnum
1046 # number of directories until either file_write returns an error or the
1047 # maximum number of files per directory have been written.
1048 #
1049 # Usage:
1050 # fill_fs [destdir] [dirnum] [filenum] [bytes] [num_writes] [data]
1051 #
1052 # Return value: 0 on success
1053 #               non 0 on error
1054 #
1055 # Where :
1056 #       destdir:    is the directory where everything is to be created under
1057 #       dirnum:     the maximum number of subdirectories to use, -1 no limit
1058 #       filenum:    the maximum number of files per subdirectory
1059 #       bytes:      number of bytes to write
1060 #       num_writes: numer of types to write out bytes
1061 #       data:       the data that will be written
1062 #
1063 #       E.g.
1064 #       file_fs /testdir 20 25 1024 256 0
1065 #
1066 # Note: bytes * num_writes equals the size of the testfile
1067 #
1068 function fill_fs # destdir dirnum filenum bytes num_writes data
1069 {
1070         typeset destdir=${1:-$TESTDIR}
1071         typeset -i dirnum=${2:-50}
1072         typeset -i filenum=${3:-50}
1073         typeset -i bytes=${4:-8192}
1074         typeset -i num_writes=${5:-10240}
1075         typeset -i data=${6:-0}
1076
1077         typeset -i odirnum=1
1078         typeset -i idirnum=0
1079         typeset -i fn=0
1080         typeset -i retval=0
1081
1082         log_must mkdir -p $destdir/$idirnum
1083         while (($odirnum > 0)); do
1084                 if ((dirnum >= 0 && idirnum >= dirnum)); then
1085                         odirnum=0
1086                         break
1087                 fi
1088                 file_write -o create -f $destdir/$idirnum/$TESTFILE.$fn \
1089                     -b $bytes -c $num_writes -d $data
1090                 retval=$?
1091                 if (($retval != 0)); then
1092                         odirnum=0
1093                         break
1094                 fi
1095                 if (($fn >= $filenum)); then
1096                         fn=0
1097                         ((idirnum = idirnum + 1))
1098                         log_must mkdir -p $destdir/$idirnum
1099                 else
1100                         ((fn = fn + 1))
1101                 fi
1102         done
1103         return $retval
1104 }
1105
1106 #
1107 # Simple function to get the specified property. If unable to
1108 # get the property then exits.
1109 #
1110 # Note property is in 'parsable' format (-p)
1111 #
1112 function get_prop # property dataset
1113 {
1114         typeset prop_val
1115         typeset prop=$1
1116         typeset dataset=$2
1117
1118         prop_val=$(zfs get -pH -o value $prop $dataset 2>/dev/null)
1119         if [[ $? -ne 0 ]]; then
1120                 log_note "Unable to get $prop property for dataset " \
1121                 "$dataset"
1122                 return 1
1123         fi
1124
1125         echo "$prop_val"
1126         return 0
1127 }
1128
1129 #
1130 # Simple function to get the specified property of pool. If unable to
1131 # get the property then exits.
1132 #
1133 # Note property is in 'parsable' format (-p)
1134 #
1135 function get_pool_prop # property pool
1136 {
1137         typeset prop_val
1138         typeset prop=$1
1139         typeset pool=$2
1140
1141         if poolexists $pool ; then
1142                 prop_val=$(zpool get -pH $prop $pool 2>/dev/null | tail -1 | \
1143                         awk '{print $3}')
1144                 if [[ $? -ne 0 ]]; then
1145                         log_note "Unable to get $prop property for pool " \
1146                         "$pool"
1147                         return 1
1148                 fi
1149         else
1150                 log_note "Pool $pool not exists."
1151                 return 1
1152         fi
1153
1154         echo "$prop_val"
1155         return 0
1156 }
1157
1158 # Return 0 if a pool exists; $? otherwise
1159 #
1160 # $1 - pool name
1161
1162 function poolexists
1163 {
1164         typeset pool=$1
1165
1166         if [[ -z $pool ]]; then
1167                 log_note "No pool name given."
1168                 return 1
1169         fi
1170
1171         zpool get name "$pool" > /dev/null 2>&1
1172         return $?
1173 }
1174
1175 # Return 0 if all the specified datasets exist; $? otherwise
1176 #
1177 # $1-n  dataset name
1178 function datasetexists
1179 {
1180         if (($# == 0)); then
1181                 log_note "No dataset name given."
1182                 return 1
1183         fi
1184
1185         while (($# > 0)); do
1186                 zfs get name $1 > /dev/null 2>&1 || \
1187                         return $?
1188                 shift
1189         done
1190
1191         return 0
1192 }
1193
1194 # return 0 if none of the specified datasets exists, otherwise return 1.
1195 #
1196 # $1-n  dataset name
1197 function datasetnonexists
1198 {
1199         if (($# == 0)); then
1200                 log_note "No dataset name given."
1201                 return 1
1202         fi
1203
1204         while (($# > 0)); do
1205                 zfs list -H -t filesystem,snapshot,volume $1 > /dev/null 2>&1 \
1206                     && return 1
1207                 shift
1208         done
1209
1210         return 0
1211 }
1212
1213 #
1214 # Given a mountpoint, or a dataset name, determine if it is shared via NFS.
1215 #
1216 # Returns 0 if shared, 1 otherwise.
1217 #
1218 function is_shared
1219 {
1220         typeset fs=$1
1221         typeset mtpt
1222
1223         if [[ $fs != "/"* ]] ; then
1224                 if datasetnonexists "$fs" ; then
1225                         return 1
1226                 else
1227                         mtpt=$(get_prop mountpoint "$fs")
1228                         case $mtpt in
1229                                 none|legacy|-) return 1
1230                                         ;;
1231                                 *)      fs=$mtpt
1232                                         ;;
1233                         esac
1234                 fi
1235         fi
1236
1237         if is_linux; then
1238                 for mtpt in `share | awk '{print $1}'` ; do
1239                         if [[ $mtpt == $fs ]] ; then
1240                                 return 0
1241                         fi
1242                 done
1243                 return 1
1244         fi
1245
1246         for mtpt in `share | awk '{print $2}'` ; do
1247                 if [[ $mtpt == $fs ]] ; then
1248                         return 0
1249                 fi
1250         done
1251
1252         typeset stat=$(svcs -H -o STA nfs/server:default)
1253         if [[ $stat != "ON" ]]; then
1254                 log_note "Current nfs/server status: $stat"
1255         fi
1256
1257         return 1
1258 }
1259
1260 #
1261 # Given a dataset name determine if it is shared via SMB.
1262 #
1263 # Returns 0 if shared, 1 otherwise.
1264 #
1265 function is_shared_smb
1266 {
1267         typeset fs=$1
1268         typeset mtpt
1269
1270         if datasetnonexists "$fs" ; then
1271                 return 1
1272         else
1273                 fs=$(echo $fs | sed 's@/@_@g')
1274         fi
1275
1276         if is_linux; then
1277                 for mtpt in `net usershare list | awk '{print $1}'` ; do
1278                         if [[ $mtpt == $fs ]] ; then
1279                                 return 0
1280                         fi
1281                 done
1282                 return 1
1283         else
1284                 log_unsupported "Currently unsupported by the test framework"
1285                 return 1
1286         fi
1287 }
1288
1289 #
1290 # Given a mountpoint, determine if it is not shared via NFS.
1291 #
1292 # Returns 0 if not shared, 1 otherwise.
1293 #
1294 function not_shared
1295 {
1296         typeset fs=$1
1297
1298         is_shared $fs
1299         if (($? == 0)); then
1300                 return 1
1301         fi
1302
1303         return 0
1304 }
1305
1306 #
1307 # Given a dataset determine if it is not shared via SMB.
1308 #
1309 # Returns 0 if not shared, 1 otherwise.
1310 #
1311 function not_shared_smb
1312 {
1313         typeset fs=$1
1314
1315         is_shared_smb $fs
1316         if (($? == 0)); then
1317                 return 1
1318         fi
1319
1320         return 0
1321 }
1322
1323 #
1324 # Helper function to unshare a mountpoint.
1325 #
1326 function unshare_fs #fs
1327 {
1328         typeset fs=$1
1329
1330         is_shared $fs || is_shared_smb $fs
1331         if (($? == 0)); then
1332                 log_must zfs unshare $fs
1333         fi
1334
1335         return 0
1336 }
1337
1338 #
1339 # Helper function to share a NFS mountpoint.
1340 #
1341 function share_nfs #fs
1342 {
1343         typeset fs=$1
1344
1345         if is_linux; then
1346                 is_shared $fs
1347                 if (($? != 0)); then
1348                         log_must share "*:$fs"
1349                 fi
1350         else
1351                 is_shared $fs
1352                 if (($? != 0)); then
1353                         log_must share -F nfs $fs
1354                 fi
1355         fi
1356
1357         return 0
1358 }
1359
1360 #
1361 # Helper function to unshare a NFS mountpoint.
1362 #
1363 function unshare_nfs #fs
1364 {
1365         typeset fs=$1
1366
1367         if is_linux; then
1368                 is_shared $fs
1369                 if (($? == 0)); then
1370                         log_must unshare -u "*:$fs"
1371                 fi
1372         else
1373                 is_shared $fs
1374                 if (($? == 0)); then
1375                         log_must unshare -F nfs $fs
1376                 fi
1377         fi
1378
1379         return 0
1380 }
1381
1382 #
1383 # Helper function to show NFS shares.
1384 #
1385 function showshares_nfs
1386 {
1387         if is_linux; then
1388                 share -v
1389         else
1390                 share -F nfs
1391         fi
1392
1393         return 0
1394 }
1395
1396 #
1397 # Helper function to show SMB shares.
1398 #
1399 function showshares_smb
1400 {
1401         if is_linux; then
1402                 net usershare list
1403         else
1404                 share -F smb
1405         fi
1406
1407         return 0
1408 }
1409
1410 #
1411 # Check NFS server status and trigger it online.
1412 #
1413 function setup_nfs_server
1414 {
1415         # Cannot share directory in non-global zone.
1416         #
1417         if ! is_global_zone; then
1418                 log_note "Cannot trigger NFS server by sharing in LZ."
1419                 return
1420         fi
1421
1422         if is_linux; then
1423                 log_note "NFS server must started prior to running test framework."
1424                 return
1425         fi
1426
1427         typeset nfs_fmri="svc:/network/nfs/server:default"
1428         if [[ $(svcs -Ho STA $nfs_fmri) != "ON" ]]; then
1429                 #
1430                 # Only really sharing operation can enable NFS server
1431                 # to online permanently.
1432                 #
1433                 typeset dummy=/tmp/dummy
1434
1435                 if [[ -d $dummy ]]; then
1436                         log_must rm -rf $dummy
1437                 fi
1438
1439                 log_must mkdir $dummy
1440                 log_must share $dummy
1441
1442                 #
1443                 # Waiting for fmri's status to be the final status.
1444                 # Otherwise, in transition, an asterisk (*) is appended for
1445                 # instances, unshare will reverse status to 'DIS' again.
1446                 #
1447                 # Waiting for 1's at least.
1448                 #
1449                 log_must sleep 1
1450                 timeout=10
1451                 while [[ timeout -ne 0 && $(svcs -Ho STA $nfs_fmri) == *'*' ]]
1452                 do
1453                         log_must sleep 1
1454
1455                         ((timeout -= 1))
1456                 done
1457
1458                 log_must unshare $dummy
1459                 log_must rm -rf $dummy
1460         fi
1461
1462         log_note "Current NFS status: '$(svcs -Ho STA,FMRI $nfs_fmri)'"
1463 }
1464
1465 #
1466 # To verify whether calling process is in global zone
1467 #
1468 # Return 0 if in global zone, 1 in non-global zone
1469 #
1470 function is_global_zone
1471 {
1472         if is_linux; then
1473                 return 0
1474         else
1475                 typeset cur_zone=$(zonename 2>/dev/null)
1476                 if [[ $cur_zone != "global" ]]; then
1477                         return 1
1478                 fi
1479                 return 0
1480         fi
1481 }
1482
1483 #
1484 # Verify whether test is permitted to run from
1485 # global zone, local zone, or both
1486 #
1487 # $1 zone limit, could be "global", "local", or "both"(no limit)
1488 #
1489 # Return 0 if permitted, otherwise exit with log_unsupported
1490 #
1491 function verify_runnable # zone limit
1492 {
1493         typeset limit=$1
1494
1495         [[ -z $limit ]] && return 0
1496
1497         if is_global_zone ; then
1498                 case $limit in
1499                         global|both)
1500                                 ;;
1501                         local)  log_unsupported "Test is unable to run from "\
1502                                         "global zone."
1503                                 ;;
1504                         *)      log_note "Warning: unknown limit $limit - " \
1505                                         "use both."
1506                                 ;;
1507                 esac
1508         else
1509                 case $limit in
1510                         local|both)
1511                                 ;;
1512                         global) log_unsupported "Test is unable to run from "\
1513                                         "local zone."
1514                                 ;;
1515                         *)      log_note "Warning: unknown limit $limit - " \
1516                                         "use both."
1517                                 ;;
1518                 esac
1519
1520                 reexport_pool
1521         fi
1522
1523         return 0
1524 }
1525
1526 # Return 0 if create successfully or the pool exists; $? otherwise
1527 # Note: In local zones, this function should return 0 silently.
1528 #
1529 # $1 - pool name
1530 # $2-n - [keyword] devs_list
1531
1532 function create_pool #pool devs_list
1533 {
1534         typeset pool=${1%%/*}
1535
1536         shift
1537
1538         if [[ -z $pool ]]; then
1539                 log_note "Missing pool name."
1540                 return 1
1541         fi
1542
1543         if poolexists $pool ; then
1544                 destroy_pool $pool
1545         fi
1546
1547         if is_global_zone ; then
1548                 [[ -d /$pool ]] && rm -rf /$pool
1549                 log_must zpool create -f $pool $@
1550         fi
1551
1552         return 0
1553 }
1554
1555 # Return 0 if destroy successfully or the pool exists; $? otherwise
1556 # Note: In local zones, this function should return 0 silently.
1557 #
1558 # $1 - pool name
1559 # Destroy pool with the given parameters.
1560
1561 function destroy_pool #pool
1562 {
1563         typeset pool=${1%%/*}
1564         typeset mtpt
1565
1566         if [[ -z $pool ]]; then
1567                 log_note "No pool name given."
1568                 return 1
1569         fi
1570
1571         if is_global_zone ; then
1572                 if poolexists "$pool" ; then
1573                         mtpt=$(get_prop mountpoint "$pool")
1574
1575                         # At times, syseventd/udev activity can cause attempts
1576                         # to destroy a pool to fail with EBUSY. We retry a few
1577                         # times allowing failures before requiring the destroy
1578                         # to succeed.
1579                         log_must_busy zpool destroy -f $pool
1580
1581                         [[ -d $mtpt ]] && \
1582                                 log_must rm -rf $mtpt
1583                 else
1584                         log_note "Pool does not exist. ($pool)"
1585                         return 1
1586                 fi
1587         fi
1588
1589         return 0
1590 }
1591
1592 #
1593 # Firstly, create a pool with 5 datasets. Then, create a single zone and
1594 # export the 5 datasets to it. In addition, we also add a ZFS filesystem
1595 # and a zvol device to the zone.
1596 #
1597 # $1 zone name
1598 # $2 zone root directory prefix
1599 # $3 zone ip
1600 #
1601 function zfs_zones_setup #zone_name zone_root zone_ip
1602 {
1603         typeset zone_name=${1:-$(hostname)-z}
1604         typeset zone_root=${2:-"/zone_root"}
1605         typeset zone_ip=${3:-"10.1.1.10"}
1606         typeset prefix_ctr=$ZONE_CTR
1607         typeset pool_name=$ZONE_POOL
1608         typeset -i cntctr=5
1609         typeset -i i=0
1610
1611         # Create pool and 5 container within it
1612         #
1613         [[ -d /$pool_name ]] && rm -rf /$pool_name
1614         log_must zpool create -f $pool_name $DISKS
1615         while ((i < cntctr)); do
1616                 log_must zfs create $pool_name/$prefix_ctr$i
1617                 ((i += 1))
1618         done
1619
1620         # create a zvol
1621         log_must zfs create -V 1g $pool_name/zone_zvol
1622         block_device_wait
1623
1624         #
1625         # If current system support slog, add slog device for pool
1626         #
1627         if verify_slog_support ; then
1628                 typeset sdevs="$TEST_BASE_DIR/sdev1 $TEST_BASE_DIR/sdev2"
1629                 log_must mkfile $MINVDEVSIZE $sdevs
1630                 log_must zpool add $pool_name log mirror $sdevs
1631         fi
1632
1633         # this isn't supported just yet.
1634         # Create a filesystem. In order to add this to
1635         # the zone, it must have it's mountpoint set to 'legacy'
1636         # log_must zfs create $pool_name/zfs_filesystem
1637         # log_must zfs set mountpoint=legacy $pool_name/zfs_filesystem
1638
1639         [[ -d $zone_root ]] && \
1640                 log_must rm -rf $zone_root/$zone_name
1641         [[ ! -d $zone_root ]] && \
1642                 log_must mkdir -p -m 0700 $zone_root/$zone_name
1643
1644         # Create zone configure file and configure the zone
1645         #
1646         typeset zone_conf=/tmp/zone_conf.$$
1647         echo "create" > $zone_conf
1648         echo "set zonepath=$zone_root/$zone_name" >> $zone_conf
1649         echo "set autoboot=true" >> $zone_conf
1650         i=0
1651         while ((i < cntctr)); do
1652                 echo "add dataset" >> $zone_conf
1653                 echo "set name=$pool_name/$prefix_ctr$i" >> \
1654                         $zone_conf
1655                 echo "end" >> $zone_conf
1656                 ((i += 1))
1657         done
1658
1659         # add our zvol to the zone
1660         echo "add device" >> $zone_conf
1661         echo "set match=/dev/zvol/dsk/$pool_name/zone_zvol" >> $zone_conf
1662         echo "end" >> $zone_conf
1663
1664         # add a corresponding zvol rdsk to the zone
1665         echo "add device" >> $zone_conf
1666         echo "set match=$ZVOL_RDEVDIR/$pool_name/zone_zvol" >> $zone_conf
1667         echo "end" >> $zone_conf
1668
1669         # once it's supported, we'll add our filesystem to the zone
1670         # echo "add fs" >> $zone_conf
1671         # echo "set type=zfs" >> $zone_conf
1672         # echo "set special=$pool_name/zfs_filesystem" >> $zone_conf
1673         # echo "set dir=/export/zfs_filesystem" >> $zone_conf
1674         # echo "end" >> $zone_conf
1675
1676         echo "verify" >> $zone_conf
1677         echo "commit" >> $zone_conf
1678         log_must zonecfg -z $zone_name -f $zone_conf
1679         log_must rm -f $zone_conf
1680
1681         # Install the zone
1682         zoneadm -z $zone_name install
1683         if (($? == 0)); then
1684                 log_note "SUCCESS: zoneadm -z $zone_name install"
1685         else
1686                 log_fail "FAIL: zoneadm -z $zone_name install"
1687         fi
1688
1689         # Install sysidcfg file
1690         #
1691         typeset sysidcfg=$zone_root/$zone_name/root/etc/sysidcfg
1692         echo "system_locale=C" > $sysidcfg
1693         echo  "terminal=dtterm" >> $sysidcfg
1694         echo  "network_interface=primary {" >> $sysidcfg
1695         echo  "hostname=$zone_name" >> $sysidcfg
1696         echo  "}" >> $sysidcfg
1697         echo  "name_service=NONE" >> $sysidcfg
1698         echo  "root_password=mo791xfZ/SFiw" >> $sysidcfg
1699         echo  "security_policy=NONE" >> $sysidcfg
1700         echo  "timezone=US/Eastern" >> $sysidcfg
1701
1702         # Boot this zone
1703         log_must zoneadm -z $zone_name boot
1704 }
1705
1706 #
1707 # Reexport TESTPOOL & TESTPOOL(1-4)
1708 #
1709 function reexport_pool
1710 {
1711         typeset -i cntctr=5
1712         typeset -i i=0
1713
1714         while ((i < cntctr)); do
1715                 if ((i == 0)); then
1716                         TESTPOOL=$ZONE_POOL/$ZONE_CTR$i
1717                         if ! ismounted $TESTPOOL; then
1718                                 log_must zfs mount $TESTPOOL
1719                         fi
1720                 else
1721                         eval TESTPOOL$i=$ZONE_POOL/$ZONE_CTR$i
1722                         if eval ! ismounted \$TESTPOOL$i; then
1723                                 log_must eval zfs mount \$TESTPOOL$i
1724                         fi
1725                 fi
1726                 ((i += 1))
1727         done
1728 }
1729
1730 #
1731 # Verify a given disk or pool state
1732 #
1733 # Return 0 is pool/disk matches expected state, 1 otherwise
1734 #
1735 function check_state # pool disk state{online,offline,degraded}
1736 {
1737         typeset pool=$1
1738         typeset disk=${2#$DEV_DSKDIR/}
1739         typeset state=$3
1740
1741         [[ -z $pool ]] || [[ -z $state ]] \
1742             && log_fail "Arguments invalid or missing"
1743
1744         if [[ -z $disk ]]; then
1745                 #check pool state only
1746                 zpool get -H -o value health $pool \
1747                     | grep -i "$state" > /dev/null 2>&1
1748         else
1749                 zpool status -v $pool | grep "$disk"  \
1750                     | grep -i "$state" > /dev/null 2>&1
1751         fi
1752
1753         return $?
1754 }
1755
1756 #
1757 # Get the mountpoint of snapshot
1758 # For the snapshot use <mp_filesystem>/.zfs/snapshot/<snap>
1759 # as its mountpoint
1760 #
1761 function snapshot_mountpoint
1762 {
1763         typeset dataset=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
1764
1765         if [[ $dataset != *@* ]]; then
1766                 log_fail "Error name of snapshot '$dataset'."
1767         fi
1768
1769         typeset fs=${dataset%@*}
1770         typeset snap=${dataset#*@}
1771
1772         if [[ -z $fs || -z $snap ]]; then
1773                 log_fail "Error name of snapshot '$dataset'."
1774         fi
1775
1776         echo $(get_prop mountpoint $fs)/.zfs/snapshot/$snap
1777 }
1778
1779 #
1780 # Given a device and 'ashift' value verify it's correctly set on every label
1781 #
1782 function verify_ashift # device ashift
1783 {
1784         typeset device="$1"
1785         typeset ashift="$2"
1786
1787         zdb -e -lll $device | awk -v ashift=$ashift '/ashift: / {
1788             if (ashift != $2)
1789                 exit 1;
1790             else
1791                 count++;
1792             } END {
1793             if (count != 4)
1794                 exit 1;
1795             else
1796                 exit 0;
1797             }'
1798
1799         return $?
1800 }
1801
1802 #
1803 # Given a pool and file system, this function will verify the file system
1804 # using the zdb internal tool. Note that the pool is exported and imported
1805 # to ensure it has consistent state.
1806 #
1807 function verify_filesys # pool filesystem dir
1808 {
1809         typeset pool="$1"
1810         typeset filesys="$2"
1811         typeset zdbout="/tmp/zdbout.$$"
1812
1813         shift
1814         shift
1815         typeset dirs=$@
1816         typeset search_path=""
1817
1818         log_note "Calling zdb to verify filesystem '$filesys'"
1819         zfs unmount -a > /dev/null 2>&1
1820         log_must zpool export $pool
1821
1822         if [[ -n $dirs ]] ; then
1823                 for dir in $dirs ; do
1824                         search_path="$search_path -d $dir"
1825                 done
1826         fi
1827
1828         log_must zpool import $search_path $pool
1829
1830         zdb -cudi $filesys > $zdbout 2>&1
1831         if [[ $? != 0 ]]; then
1832                 log_note "Output: zdb -cudi $filesys"
1833                 cat $zdbout
1834                 log_fail "zdb detected errors with: '$filesys'"
1835         fi
1836
1837         log_must zfs mount -a
1838         log_must rm -rf $zdbout
1839 }
1840
1841 #
1842 # Given a pool, and this function list all disks in the pool
1843 #
1844 function get_disklist # pool
1845 {
1846         typeset disklist=""
1847
1848         disklist=$(zpool iostat -v $1 | nawk '(NR >4) {print $1}' | \
1849             grep -v "\-\-\-\-\-" | \
1850             egrep -v -e "^(mirror|raidz1|raidz2|spare|log|cache)$")
1851
1852         echo $disklist
1853 }
1854
1855 #
1856 # Given a pool, and this function list all disks in the pool with their full
1857 # path (like "/dev/sda" instead of "sda").
1858 #
1859 function get_disklist_fullpath # pool
1860 {
1861         args="-P $1"
1862         get_disklist $args
1863 }
1864
1865
1866
1867 # /**
1868 #  This function kills a given list of processes after a time period. We use
1869 #  this in the stress tests instead of STF_TIMEOUT so that we can have processes
1870 #  run for a fixed amount of time, yet still pass. Tests that hit STF_TIMEOUT
1871 #  would be listed as FAIL, which we don't want : we're happy with stress tests
1872 #  running for a certain amount of time, then finishing.
1873 #
1874 # @param $1 the time in seconds after which we should terminate these processes
1875 # @param $2..$n the processes we wish to terminate.
1876 # */
1877 function stress_timeout
1878 {
1879         typeset -i TIMEOUT=$1
1880         shift
1881         typeset cpids="$@"
1882
1883         log_note "Waiting for child processes($cpids). " \
1884                 "It could last dozens of minutes, please be patient ..."
1885         log_must sleep $TIMEOUT
1886
1887         log_note "Killing child processes after ${TIMEOUT} stress timeout."
1888         typeset pid
1889         for pid in $cpids; do
1890                 ps -p $pid > /dev/null 2>&1
1891                 if (($? == 0)); then
1892                         log_must kill -USR1 $pid
1893                 fi
1894         done
1895 }
1896
1897 #
1898 # Verify a given hotspare disk is inuse or avail
1899 #
1900 # Return 0 is pool/disk matches expected state, 1 otherwise
1901 #
1902 function check_hotspare_state # pool disk state{inuse,avail}
1903 {
1904         typeset pool=$1
1905         typeset disk=${2#$DEV_DSKDIR/}
1906         typeset state=$3
1907
1908         cur_state=$(get_device_state $pool $disk "spares")
1909
1910         if [[ $state != ${cur_state} ]]; then
1911                 return 1
1912         fi
1913         return 0
1914 }
1915
1916 #
1917 # Wait until a hotspare transitions to a given state or times out.
1918 #
1919 # Return 0 when  pool/disk matches expected state, 1 on timeout.
1920 #
1921 function wait_hotspare_state # pool disk state timeout
1922 {
1923         typeset pool=$1
1924         typeset disk=${2#$/DEV_DSKDIR/}
1925         typeset state=$3
1926         typeset timeout=${4:-60}
1927         typeset -i i=0
1928
1929         while [[ $i -lt $timeout ]]; do
1930                 if check_hotspare_state $pool $disk $state; then
1931                         return 0
1932                 fi
1933
1934                 i=$((i+1))
1935                 sleep 1
1936         done
1937
1938         return 1
1939 }
1940
1941 #
1942 # Verify a given slog disk is inuse or avail
1943 #
1944 # Return 0 is pool/disk matches expected state, 1 otherwise
1945 #
1946 function check_slog_state # pool disk state{online,offline,unavail}
1947 {
1948         typeset pool=$1
1949         typeset disk=${2#$DEV_DSKDIR/}
1950         typeset state=$3
1951
1952         cur_state=$(get_device_state $pool $disk "logs")
1953
1954         if [[ $state != ${cur_state} ]]; then
1955                 return 1
1956         fi
1957         return 0
1958 }
1959
1960 #
1961 # Verify a given vdev disk is inuse or avail
1962 #
1963 # Return 0 is pool/disk matches expected state, 1 otherwise
1964 #
1965 function check_vdev_state # pool disk state{online,offline,unavail}
1966 {
1967         typeset pool=$1
1968         typeset disk=${2#$/DEV_DSKDIR/}
1969         typeset state=$3
1970
1971         cur_state=$(get_device_state $pool $disk)
1972
1973         if [[ $state != ${cur_state} ]]; then
1974                 return 1
1975         fi
1976         return 0
1977 }
1978
1979 #
1980 # Wait until a vdev transitions to a given state or times out.
1981 #
1982 # Return 0 when  pool/disk matches expected state, 1 on timeout.
1983 #
1984 function wait_vdev_state # pool disk state timeout
1985 {
1986         typeset pool=$1
1987         typeset disk=${2#$/DEV_DSKDIR/}
1988         typeset state=$3
1989         typeset timeout=${4:-60}
1990         typeset -i i=0
1991
1992         while [[ $i -lt $timeout ]]; do
1993                 if check_vdev_state $pool $disk $state; then
1994                         return 0
1995                 fi
1996
1997                 i=$((i+1))
1998                 sleep 1
1999         done
2000
2001         return 1
2002 }
2003
2004 #
2005 # Check the output of 'zpool status -v <pool>',
2006 # and to see if the content of <token> contain the <keyword> specified.
2007 #
2008 # Return 0 is contain, 1 otherwise
2009 #
2010 function check_pool_status # pool token keyword <verbose>
2011 {
2012         typeset pool=$1
2013         typeset token=$2
2014         typeset keyword=$3
2015         typeset verbose=${4:-false}
2016
2017         scan=$(zpool status -v "$pool" 2>/dev/null | nawk -v token="$token:" '
2018                 ($1==token) {print $0}')
2019         if [[ $verbose == true ]]; then
2020                 log_note $scan
2021         fi
2022         echo $scan | grep -i "$keyword" > /dev/null 2>&1
2023
2024         return $?
2025 }
2026
2027 #
2028 # These 6 following functions are instance of check_pool_status()
2029 #       is_pool_resilvering - to check if the pool is resilver in progress
2030 #       is_pool_resilvered - to check if the pool is resilver completed
2031 #       is_pool_scrubbing - to check if the pool is scrub in progress
2032 #       is_pool_scrubbed - to check if the pool is scrub completed
2033 #       is_pool_scrub_stopped - to check if the pool is scrub stopped
2034 #       is_pool_scrub_paused - to check if the pool has scrub paused
2035 #
2036 function is_pool_resilvering #pool <verbose>
2037 {
2038         check_pool_status "$1" "scan" "resilver in progress since " $2
2039         return $?
2040 }
2041
2042 function is_pool_resilvered #pool <verbose>
2043 {
2044         check_pool_status "$1" "scan" "resilvered " $2
2045         return $?
2046 }
2047
2048 function is_pool_scrubbing #pool <verbose>
2049 {
2050         check_pool_status "$1" "scan" "scrub in progress since " $2
2051         return $?
2052 }
2053
2054 function is_pool_scrubbed #pool <verbose>
2055 {
2056         check_pool_status "$1" "scan" "scrub repaired" $2
2057         return $?
2058 }
2059
2060 function is_pool_scrub_stopped #pool <verbose>
2061 {
2062         check_pool_status "$1" "scan" "scrub canceled" $2
2063         return $?
2064 }
2065
2066 function is_pool_scrub_paused #pool <verbose>
2067 {
2068         check_pool_status "$1" "scan" "scrub paused since " $2
2069         return $?
2070 }
2071
2072 #
2073 # Use create_pool()/destroy_pool() to clean up the information in
2074 # in the given disk to avoid slice overlapping.
2075 #
2076 function cleanup_devices #vdevs
2077 {
2078         typeset pool="foopool$$"
2079
2080         if poolexists $pool ; then
2081                 destroy_pool $pool
2082         fi
2083
2084         create_pool $pool $@
2085         destroy_pool $pool
2086
2087         return 0
2088 }
2089
2090 #/**
2091 # A function to find and locate free disks on a system or from given
2092 # disks as the parameter. It works by locating disks that are in use
2093 # as swap devices and dump devices, and also disks listed in /etc/vfstab
2094 #
2095 # $@ given disks to find which are free, default is all disks in
2096 # the test system
2097 #
2098 # @return a string containing the list of available disks
2099 #*/
2100 function find_disks
2101 {
2102         # Trust provided list, no attempt is made to locate unused devices.
2103         if is_linux; then
2104                 echo "$@"
2105                 return
2106         fi
2107
2108
2109         sfi=/tmp/swaplist.$$
2110         dmpi=/tmp/dumpdev.$$
2111         max_finddisksnum=${MAX_FINDDISKSNUM:-6}
2112
2113         swap -l > $sfi
2114         dumpadm > $dmpi 2>/dev/null
2115
2116 # write an awk script that can process the output of format
2117 # to produce a list of disks we know about. Note that we have
2118 # to escape "$2" so that the shell doesn't interpret it while
2119 # we're creating the awk script.
2120 # -------------------
2121         cat > /tmp/find_disks.awk <<EOF
2122 #!/bin/nawk -f
2123         BEGIN { FS="."; }
2124
2125         /^Specify disk/{
2126                 searchdisks=0;
2127         }
2128
2129         {
2130                 if (searchdisks && \$2 !~ "^$"){
2131                         split(\$2,arr," ");
2132                         print arr[1];
2133                 }
2134         }
2135
2136         /^AVAILABLE DISK SELECTIONS:/{
2137                 searchdisks=1;
2138         }
2139 EOF
2140 #---------------------
2141
2142         chmod 755 /tmp/find_disks.awk
2143         disks=${@:-$(echo "" | format -e 2>/dev/null | /tmp/find_disks.awk)}
2144         rm /tmp/find_disks.awk
2145
2146         unused=""
2147         for disk in $disks; do
2148         # Check for mounted
2149                 grep "${disk}[sp]" /etc/mnttab >/dev/null
2150                 (($? == 0)) && continue
2151         # Check for swap
2152                 grep "${disk}[sp]" $sfi >/dev/null
2153                 (($? == 0)) && continue
2154         # check for dump device
2155                 grep "${disk}[sp]" $dmpi >/dev/null
2156                 (($? == 0)) && continue
2157         # check to see if this disk hasn't been explicitly excluded
2158         # by a user-set environment variable
2159                 echo "${ZFS_HOST_DEVICES_IGNORE}" | grep "${disk}" > /dev/null
2160                 (($? == 0)) && continue
2161                 unused_candidates="$unused_candidates $disk"
2162         done
2163         rm $sfi
2164         rm $dmpi
2165
2166 # now just check to see if those disks do actually exist
2167 # by looking for a device pointing to the first slice in
2168 # each case. limit the number to max_finddisksnum
2169         count=0
2170         for disk in $unused_candidates; do
2171                 if [ -b $DEV_DSKDIR/${disk}s0 ]; then
2172                 if [ $count -lt $max_finddisksnum ]; then
2173                         unused="$unused $disk"
2174                         # do not impose limit if $@ is provided
2175                         [[ -z $@ ]] && ((count = count + 1))
2176                 fi
2177                 fi
2178         done
2179
2180 # finally, return our disk list
2181         echo $unused
2182 }
2183
2184 #
2185 # Add specified user to specified group
2186 #
2187 # $1 group name
2188 # $2 user name
2189 # $3 base of the homedir (optional)
2190 #
2191 function add_user #<group_name> <user_name> <basedir>
2192 {
2193         typeset gname=$1
2194         typeset uname=$2
2195         typeset basedir=${3:-"/var/tmp"}
2196
2197         if ((${#gname} == 0 || ${#uname} == 0)); then
2198                 log_fail "group name or user name are not defined."
2199         fi
2200
2201         log_must useradd -g $gname -d $basedir/$uname -m $uname
2202         echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.profile
2203         echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.bash_profile
2204         echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.login
2205
2206         # Add new users to the same group and the command line utils.
2207         # This allows them to be run out of the original users home
2208         # directory as long as it permissioned to be group readable.
2209         if is_linux; then
2210                 cmd_group=$(stat --format="%G" $(which zfs))
2211                 log_must usermod -a -G $cmd_group $uname
2212         fi
2213
2214         return 0
2215 }
2216
2217 #
2218 # Delete the specified user.
2219 #
2220 # $1 login name
2221 # $2 base of the homedir (optional)
2222 #
2223 function del_user #<logname> <basedir>
2224 {
2225         typeset user=$1
2226         typeset basedir=${2:-"/var/tmp"}
2227
2228         if ((${#user} == 0)); then
2229                 log_fail "login name is necessary."
2230         fi
2231
2232         if id $user > /dev/null 2>&1; then
2233                 log_must_retry "currently used" 5 userdel $user
2234         fi
2235
2236         [[ -d $basedir/$user ]] && rm -fr $basedir/$user
2237
2238         return 0
2239 }
2240
2241 #
2242 # Select valid gid and create specified group.
2243 #
2244 # $1 group name
2245 #
2246 function add_group #<group_name>
2247 {
2248         typeset group=$1
2249
2250         if ((${#group} == 0)); then
2251                 log_fail "group name is necessary."
2252         fi
2253
2254         # Assign 100 as the base gid, a larger value is selected for
2255         # Linux because for many distributions 1000 and under are reserved.
2256         if is_linux; then
2257                 while true; do
2258                         groupadd $group > /dev/null 2>&1
2259                         typeset -i ret=$?
2260                         case $ret in
2261                                 0) return 0 ;;
2262                                 *) return 1 ;;
2263                         esac
2264                 done
2265         else
2266                 typeset -i gid=100
2267                 while true; do
2268                         groupadd -g $gid $group > /dev/null 2>&1
2269                         typeset -i ret=$?
2270                         case $ret in
2271                                 0) return 0 ;;
2272                                 # The gid is not  unique
2273                                 4) ((gid += 1)) ;;
2274                                 *) return 1 ;;
2275                         esac
2276                 done
2277         fi
2278 }
2279
2280 #
2281 # Delete the specified group.
2282 #
2283 # $1 group name
2284 #
2285 function del_group #<group_name>
2286 {
2287         typeset grp=$1
2288         if ((${#grp} == 0)); then
2289                 log_fail "group name is necessary."
2290         fi
2291
2292         if is_linux; then
2293                 getent group $grp > /dev/null 2>&1
2294                 typeset -i ret=$?
2295                 case $ret in
2296                         # Group does not exist.
2297                         2) return 0 ;;
2298                         # Name already exists as a group name
2299                         0) log_must groupdel $grp ;;
2300                         *) return 1 ;;
2301                 esac
2302         else
2303                 groupmod -n $grp $grp > /dev/null 2>&1
2304                 typeset -i ret=$?
2305                 case $ret in
2306                         # Group does not exist.
2307                         6) return 0 ;;
2308                         # Name already exists as a group name
2309                         9) log_must groupdel $grp ;;
2310                         *) return 1 ;;
2311                 esac
2312         fi
2313
2314         return 0
2315 }
2316
2317 #
2318 # This function will return true if it's safe to destroy the pool passed
2319 # as argument 1. It checks for pools based on zvols and files, and also
2320 # files contained in a pool that may have a different mountpoint.
2321 #
2322 function safe_to_destroy_pool { # $1 the pool name
2323
2324         typeset pool=""
2325         typeset DONT_DESTROY=""
2326
2327         # We check that by deleting the $1 pool, we're not
2328         # going to pull the rug out from other pools. Do this
2329         # by looking at all other pools, ensuring that they
2330         # aren't built from files or zvols contained in this pool.
2331
2332         for pool in $(zpool list -H -o name)
2333         do
2334                 ALTMOUNTPOOL=""
2335
2336                 # this is a list of the top-level directories in each of the
2337                 # files that make up the path to the files the pool is based on
2338                 FILEPOOL=$(zpool status -v $pool | grep /$1/ | \
2339                         awk '{print $1}')
2340
2341                 # this is a list of the zvols that make up the pool
2342                 ZVOLPOOL=$(zpool status -v $pool | grep "$ZVOL_DEVDIR/$1$" \
2343                     | awk '{print $1}')
2344
2345                 # also want to determine if it's a file-based pool using an
2346                 # alternate mountpoint...
2347                 POOL_FILE_DIRS=$(zpool status -v $pool | \
2348                                         grep / | awk '{print $1}' | \
2349                                         awk -F/ '{print $2}' | grep -v "dev")
2350
2351                 for pooldir in $POOL_FILE_DIRS
2352                 do
2353                         OUTPUT=$(zfs list -H -r -o mountpoint $1 | \
2354                                         grep "${pooldir}$" | awk '{print $1}')
2355
2356                         ALTMOUNTPOOL="${ALTMOUNTPOOL}${OUTPUT}"
2357                 done
2358
2359
2360                 if [ ! -z "$ZVOLPOOL" ]
2361                 then
2362                         DONT_DESTROY="true"
2363                         log_note "Pool $pool is built from $ZVOLPOOL on $1"
2364                 fi
2365
2366                 if [ ! -z "$FILEPOOL" ]
2367                 then
2368                         DONT_DESTROY="true"
2369                         log_note "Pool $pool is built from $FILEPOOL on $1"
2370                 fi
2371
2372                 if [ ! -z "$ALTMOUNTPOOL" ]
2373                 then
2374                         DONT_DESTROY="true"
2375                         log_note "Pool $pool is built from $ALTMOUNTPOOL on $1"
2376                 fi
2377         done
2378
2379         if [ -z "${DONT_DESTROY}" ]
2380         then
2381                 return 0
2382         else
2383                 log_note "Warning: it is not safe to destroy $1!"
2384                 return 1
2385         fi
2386 }
2387
2388 #
2389 # Get the available ZFS compression options
2390 # $1 option type zfs_set|zfs_compress
2391 #
2392 function get_compress_opts
2393 {
2394         typeset COMPRESS_OPTS
2395         typeset GZIP_OPTS="gzip gzip-1 gzip-2 gzip-3 gzip-4 gzip-5 \
2396                         gzip-6 gzip-7 gzip-8 gzip-9"
2397
2398         if [[ $1 == "zfs_compress" ]] ; then
2399                 COMPRESS_OPTS="on lzjb"
2400         elif [[ $1 == "zfs_set" ]] ; then
2401                 COMPRESS_OPTS="on off lzjb"
2402         fi
2403         typeset valid_opts="$COMPRESS_OPTS"
2404         zfs get 2>&1 | grep gzip >/dev/null 2>&1
2405         if [[ $? -eq 0 ]]; then
2406                 valid_opts="$valid_opts $GZIP_OPTS"
2407         fi
2408         echo "$valid_opts"
2409 }
2410
2411 #
2412 # Verify zfs operation with -p option work as expected
2413 # $1 operation, value could be create, clone or rename
2414 # $2 dataset type, value could be fs or vol
2415 # $3 dataset name
2416 # $4 new dataset name
2417 #
2418 function verify_opt_p_ops
2419 {
2420         typeset ops=$1
2421         typeset datatype=$2
2422         typeset dataset=$3
2423         typeset newdataset=$4
2424
2425         if [[ $datatype != "fs" && $datatype != "vol" ]]; then
2426                 log_fail "$datatype is not supported."
2427         fi
2428
2429         # check parameters accordingly
2430         case $ops in
2431                 create)
2432                         newdataset=$dataset
2433                         dataset=""
2434                         if [[ $datatype == "vol" ]]; then
2435                                 ops="create -V $VOLSIZE"
2436                         fi
2437                         ;;
2438                 clone)
2439                         if [[ -z $newdataset ]]; then
2440                                 log_fail "newdataset should not be empty" \
2441                                         "when ops is $ops."
2442                         fi
2443                         log_must datasetexists $dataset
2444                         log_must snapexists $dataset
2445                         ;;
2446                 rename)
2447                         if [[ -z $newdataset ]]; then
2448                                 log_fail "newdataset should not be empty" \
2449                                         "when ops is $ops."
2450                         fi
2451                         log_must datasetexists $dataset
2452                         log_mustnot snapexists $dataset
2453                         ;;
2454                 *)
2455                         log_fail "$ops is not supported."
2456                         ;;
2457         esac
2458
2459         # make sure the upper level filesystem does not exist
2460         if datasetexists ${newdataset%/*} ; then
2461                 log_must zfs destroy -rRf ${newdataset%/*}
2462         fi
2463
2464         # without -p option, operation will fail
2465         log_mustnot zfs $ops $dataset $newdataset
2466         log_mustnot datasetexists $newdataset ${newdataset%/*}
2467
2468         # with -p option, operation should succeed
2469         log_must zfs $ops -p $dataset $newdataset
2470         block_device_wait
2471
2472         if ! datasetexists $newdataset ; then
2473                 log_fail "-p option does not work for $ops"
2474         fi
2475
2476         # when $ops is create or clone, redo the operation still return zero
2477         if [[ $ops != "rename" ]]; then
2478                 log_must zfs $ops -p $dataset $newdataset
2479         fi
2480
2481         return 0
2482 }
2483
2484 #
2485 # Get configuration of pool
2486 # $1 pool name
2487 # $2 config name
2488 #
2489 function get_config
2490 {
2491         typeset pool=$1
2492         typeset config=$2
2493         typeset alt_root
2494
2495         if ! poolexists "$pool" ; then
2496                 return 1
2497         fi
2498         alt_root=$(zpool list -H $pool | awk '{print $NF}')
2499         if [[ $alt_root == "-" ]]; then
2500                 value=$(zdb -C $pool | grep "$config:" | awk -F: \
2501                     '{print $2}')
2502         else
2503                 value=$(zdb -e $pool | grep "$config:" | awk -F: \
2504                     '{print $2}')
2505         fi
2506         if [[ -n $value ]] ; then
2507                 value=${value#'}
2508                 value=${value%'}
2509         fi
2510         echo $value
2511
2512         return 0
2513 }
2514
2515 #
2516 # Privated function. Random select one of items from arguments.
2517 #
2518 # $1 count
2519 # $2-n string
2520 #
2521 function _random_get
2522 {
2523         typeset cnt=$1
2524         shift
2525
2526         typeset str="$@"
2527         typeset -i ind
2528         ((ind = RANDOM % cnt + 1))
2529
2530         typeset ret=$(echo "$str" | cut -f $ind -d ' ')
2531         echo $ret
2532 }
2533
2534 #
2535 # Random select one of item from arguments which include NONE string
2536 #
2537 function random_get_with_non
2538 {
2539         typeset -i cnt=$#
2540         ((cnt =+ 1))
2541
2542         _random_get "$cnt" "$@"
2543 }
2544
2545 #
2546 # Random select one of item from arguments which doesn't include NONE string
2547 #
2548 function random_get
2549 {
2550         _random_get "$#" "$@"
2551 }
2552
2553 #
2554 # Detect if the current system support slog
2555 #
2556 function verify_slog_support
2557 {
2558         typeset dir=$TEST_BASE_DIR/disk.$$
2559         typeset pool=foo.$$
2560         typeset vdev=$dir/a
2561         typeset sdev=$dir/b
2562
2563         mkdir -p $dir
2564         mkfile $MINVDEVSIZE $vdev $sdev
2565
2566         typeset -i ret=0
2567         if ! zpool create -n $pool $vdev log $sdev > /dev/null 2>&1; then
2568                 ret=1
2569         fi
2570         rm -r $dir
2571
2572         return $ret
2573 }
2574
2575 #
2576 # The function will generate a dataset name with specific length
2577 # $1, the length of the name
2578 # $2, the base string to construct the name
2579 #
2580 function gen_dataset_name
2581 {
2582         typeset -i len=$1
2583         typeset basestr="$2"
2584         typeset -i baselen=${#basestr}
2585         typeset -i iter=0
2586         typeset l_name=""
2587
2588         if ((len % baselen == 0)); then
2589                 ((iter = len / baselen))
2590         else
2591                 ((iter = len / baselen + 1))
2592         fi
2593         while ((iter > 0)); do
2594                 l_name="${l_name}$basestr"
2595
2596                 ((iter -= 1))
2597         done
2598
2599         echo $l_name
2600 }
2601
2602 #
2603 # Get cksum tuple of dataset
2604 # $1 dataset name
2605 #
2606 # sample zdb output:
2607 # Dataset data/test [ZPL], ID 355, cr_txg 2413856, 31.0K, 7 objects, rootbp
2608 # DVA[0]=<0:803046400:200> DVA[1]=<0:81199000:200> [L0 DMU objset] fletcher4
2609 # lzjb LE contiguous unique double size=800L/200P birth=2413856L/2413856P
2610 # fill=7 cksum=11ce125712:643a9c18ee2:125e25238fca0:254a3f74b59744
2611 function datasetcksum
2612 {
2613         typeset cksum
2614         sync
2615         cksum=$(zdb -vvv $1 | grep "^Dataset $1 \[" | grep "cksum" \
2616                 | awk -F= '{print $7}')
2617         echo $cksum
2618 }
2619
2620 #
2621 # Get cksum of file
2622 # #1 file path
2623 #
2624 function checksum
2625 {
2626         typeset cksum
2627         cksum=$(cksum $1 | awk '{print $1}')
2628         echo $cksum
2629 }
2630
2631 #
2632 # Get the given disk/slice state from the specific field of the pool
2633 #
2634 function get_device_state #pool disk field("", "spares","logs")
2635 {
2636         typeset pool=$1
2637         typeset disk=${2#$DEV_DSKDIR/}
2638         typeset field=${3:-$pool}
2639
2640         state=$(zpool status -v "$pool" 2>/dev/null | \
2641                 nawk -v device=$disk -v pool=$pool -v field=$field \
2642                 'BEGIN {startconfig=0; startfield=0; }
2643                 /config:/ {startconfig=1}
2644                 (startconfig==1) && ($1==field) {startfield=1; next;}
2645                 (startfield==1) && ($1==device) {print $2; exit;}
2646                 (startfield==1) &&
2647                 ($1==field || $1 ~ "^spares$" || $1 ~ "^logs$") {startfield=0}')
2648         echo $state
2649 }
2650
2651
2652 #
2653 # print the given directory filesystem type
2654 #
2655 # $1 directory name
2656 #
2657 function get_fstype
2658 {
2659         typeset dir=$1
2660
2661         if [[ -z $dir ]]; then
2662                 log_fail "Usage: get_fstype <directory>"
2663         fi
2664
2665         #
2666         #  $ df -n /
2667         #  /              : ufs
2668         #
2669         df -n $dir | awk '{print $3}'
2670 }
2671
2672 #
2673 # Given a disk, label it to VTOC regardless what label was on the disk
2674 # $1 disk
2675 #
2676 function labelvtoc
2677 {
2678         typeset disk=$1
2679         if [[ -z $disk ]]; then
2680                 log_fail "The disk name is unspecified."
2681         fi
2682         typeset label_file=/var/tmp/labelvtoc.$$
2683         typeset arch=$(uname -p)
2684
2685         if is_linux; then
2686                 log_note "Currently unsupported by the test framework"
2687                 return 1
2688         fi
2689
2690         if [[ $arch == "i386" ]]; then
2691                 echo "label" > $label_file
2692                 echo "0" >> $label_file
2693                 echo "" >> $label_file
2694                 echo "q" >> $label_file
2695                 echo "q" >> $label_file
2696
2697                 fdisk -B $disk >/dev/null 2>&1
2698                 # wait a while for fdisk finishes
2699                 sleep 60
2700         elif [[ $arch == "sparc" ]]; then
2701                 echo "label" > $label_file
2702                 echo "0" >> $label_file
2703                 echo "" >> $label_file
2704                 echo "" >> $label_file
2705                 echo "" >> $label_file
2706                 echo "q" >> $label_file
2707         else
2708                 log_fail "unknown arch type"
2709         fi
2710
2711         format -e -s -d $disk -f $label_file
2712         typeset -i ret_val=$?
2713         rm -f $label_file
2714         #
2715         # wait the format to finish
2716         #
2717         sleep 60
2718         if ((ret_val != 0)); then
2719                 log_fail "unable to label $disk as VTOC."
2720         fi
2721
2722         return 0
2723 }
2724
2725 #
2726 # check if the system was installed as zfsroot or not
2727 # return: 0 ture, otherwise false
2728 #
2729 function is_zfsroot
2730 {
2731         df -n / | grep zfs > /dev/null 2>&1
2732         return $?
2733 }
2734
2735 #
2736 # get the root filesystem name if it's zfsroot system.
2737 #
2738 # return: root filesystem name
2739 function get_rootfs
2740 {
2741         typeset rootfs=""
2742
2743         if ! is_linux; then
2744                 rootfs=$(awk '{if ($2 == "/" && $3 == "zfs") print $1}' \
2745                         /etc/mnttab)
2746         fi
2747         if [[ -z "$rootfs" ]]; then
2748                 log_fail "Can not get rootfs"
2749         fi
2750         zfs list $rootfs > /dev/null 2>&1
2751         if (($? == 0)); then
2752                 echo $rootfs
2753         else
2754                 log_fail "This is not a zfsroot system."
2755         fi
2756 }
2757
2758 #
2759 # get the rootfs's pool name
2760 # return:
2761 #       rootpool name
2762 #
2763 function get_rootpool
2764 {
2765         typeset rootfs=""
2766         typeset rootpool=""
2767
2768         if ! is_linux; then
2769                 rootfs=$(awk '{if ($2 == "/" && $3 =="zfs") print $1}' \
2770                          /etc/mnttab)
2771         fi
2772         if [[ -z "$rootfs" ]]; then
2773                 log_fail "Can not get rootpool"
2774         fi
2775         zfs list $rootfs > /dev/null 2>&1
2776         if (($? == 0)); then
2777                 rootpool=`echo $rootfs | awk -F\/ '{print $1}'`
2778                 echo $rootpool
2779         else
2780                 log_fail "This is not a zfsroot system."
2781         fi
2782 }
2783
2784 #
2785 # Get the package name
2786 #
2787 function get_package_name
2788 {
2789         typeset dirpath=${1:-$STC_NAME}
2790
2791         echo "SUNWstc-${dirpath}" | /usr/bin/sed -e "s/\//-/g"
2792 }
2793
2794 #
2795 # Get the word numbers from a string separated by white space
2796 #
2797 function get_word_count
2798 {
2799         echo $1 | wc -w
2800 }
2801
2802 #
2803 # To verify if the require numbers of disks is given
2804 #
2805 function verify_disk_count
2806 {
2807         typeset -i min=${2:-1}
2808
2809         typeset -i count=$(get_word_count "$1")
2810
2811         if ((count < min)); then
2812                 log_untested "A minimum of $min disks is required to run." \
2813                         " You specified $count disk(s)"
2814         fi
2815 }
2816
2817 function ds_is_volume
2818 {
2819         typeset type=$(get_prop type $1)
2820         [[ $type = "volume" ]] && return 0
2821         return 1
2822 }
2823
2824 function ds_is_filesystem
2825 {
2826         typeset type=$(get_prop type $1)
2827         [[ $type = "filesystem" ]] && return 0
2828         return 1
2829 }
2830
2831 function ds_is_snapshot
2832 {
2833         typeset type=$(get_prop type $1)
2834         [[ $type = "snapshot" ]] && return 0
2835         return 1
2836 }
2837
2838 #
2839 # Check if Trusted Extensions are installed and enabled
2840 #
2841 function is_te_enabled
2842 {
2843         svcs -H -o state labeld 2>/dev/null | grep "enabled"
2844         if (($? != 0)); then
2845                 return 1
2846         else
2847                 return 0
2848         fi
2849 }
2850
2851 # Utility function to determine if a system has multiple cpus.
2852 function is_mp
2853 {
2854         if is_linux; then
2855                 (($(nproc) > 1))
2856         else
2857                 (($(psrinfo | wc -l) > 1))
2858         fi
2859
2860         return $?
2861 }
2862
2863 function get_cpu_freq
2864 {
2865         if is_linux; then
2866                 lscpu | awk '/CPU MHz/ { print $3 }'
2867         else
2868                 psrinfo -v 0 | awk '/processor operates at/ {print $6}'
2869         fi
2870 }
2871
2872 # Run the given command as the user provided.
2873 function user_run
2874 {
2875         typeset user=$1
2876         shift
2877
2878         log_note "user:$user $@"
2879         eval su - \$user -c \"$@\" > /tmp/out 2>/tmp/err
2880         return $?
2881 }
2882
2883 #
2884 # Check if the pool contains the specified vdevs
2885 #
2886 # $1 pool
2887 # $2..n <vdev> ...
2888 #
2889 # Return 0 if the vdevs are contained in the pool, 1 if any of the specified
2890 # vdevs is not in the pool, and 2 if pool name is missing.
2891 #
2892 function vdevs_in_pool
2893 {
2894         typeset pool=$1
2895         typeset vdev
2896
2897         if [[ -z $pool ]]; then
2898                 log_note "Missing pool name."
2899                 return 2
2900         fi
2901
2902         shift
2903
2904         typeset tmpfile=$(mktemp)
2905         zpool list -Hv "$pool" >$tmpfile
2906         for vdev in $@; do
2907                 grep -w ${vdev##*/} $tmpfile >/dev/null 2>&1
2908                 [[ $? -ne 0 ]] && return 1
2909         done
2910
2911         rm -f $tmpfile
2912
2913         return 0;
2914 }
2915
2916 function get_max
2917 {
2918         typeset -l i max=$1
2919         shift
2920
2921         for i in "$@"; do
2922                 max=$(echo $((max > i ? max : i)))
2923         done
2924
2925         echo $max
2926 }
2927
2928 function get_min
2929 {
2930         typeset -l i min=$1
2931         shift
2932
2933         for i in "$@"; do
2934                 min=$(echo $((min < i ? min : i)))
2935         done
2936
2937         echo $min
2938 }
2939
2940 #
2941 # Generate a random number between 1 and the argument.
2942 #
2943 function random
2944 {
2945         typeset max=$1
2946         echo $(( ($RANDOM % $max) + 1 ))
2947 }
2948
2949 # Write data that can be compressed into a directory
2950 function write_compressible
2951 {
2952         typeset dir=$1
2953         typeset megs=$2
2954         typeset nfiles=${3:-1}
2955         typeset bs=${4:-1024k}
2956         typeset fname=${5:-file}
2957
2958         [[ -d $dir ]] || log_fail "No directory: $dir"
2959
2960         # Under Linux fio is not currently used since its behavior can
2961         # differ significantly across versions.  This includes missing
2962         # command line options and cases where the --buffer_compress_*
2963         # options fail to behave as expected.
2964         if is_linux; then
2965                 typeset file_bytes=$(to_bytes $megs)
2966                 typeset bs_bytes=4096
2967                 typeset blocks=$(($file_bytes / $bs_bytes))
2968
2969                 for (( i = 0; i < $nfiles; i++ )); do
2970                         truncate -s $file_bytes $dir/$fname.$i
2971
2972                         # Write every third block to get 66% compression.
2973                         for (( j = 0; j < $blocks; j += 3 )); do
2974                                 dd if=/dev/urandom of=$dir/$fname.$i \
2975                                     seek=$j bs=$bs_bytes count=1 \
2976                                     conv=notrunc >/dev/null 2>&1
2977                         done
2978                 done
2979         else
2980                 log_must eval "fio \
2981                     --name=job \
2982                     --fallocate=0 \
2983                     --minimal \
2984                     --randrepeat=0 \
2985                     --buffer_compress_percentage=66 \
2986                     --buffer_compress_chunk=4096 \
2987                     --directory=$dir \
2988                     --numjobs=$nfiles \
2989                     --nrfiles=$nfiles \
2990                     --rw=write \
2991                     --bs=$bs \
2992                     --filesize=$megs \
2993                     --filename_format='$fname.\$jobnum' >/dev/null"
2994         fi
2995 }
2996
2997 function get_objnum
2998 {
2999         typeset pathname=$1
3000         typeset objnum
3001
3002         [[ -e $pathname ]] || log_fail "No such file or directory: $pathname"
3003         objnum=$(stat -c %i $pathname)
3004         echo $objnum
3005 }
3006
3007 #
3008 # Sync data to the pool
3009 #
3010 # $1 pool name
3011 # $2 boolean to force uberblock (and config including zpool cache file) update
3012 #
3013 function sync_pool #pool <force>
3014 {
3015         typeset pool=${1:-$TESTPOOL}
3016         typeset force=${2:-false}
3017
3018         if [[ $force == true ]]; then
3019                 log_must zpool sync -f $pool
3020         else
3021                 log_must zpool sync $pool
3022         fi
3023
3024         return 0
3025 }
3026
3027 #
3028 # Wait for zpool 'freeing' property drops to zero.
3029 #
3030 # $1 pool name
3031 #
3032 function wait_freeing #pool
3033 {
3034         typeset pool=${1:-$TESTPOOL}
3035         while true; do
3036                 [[ "0" == "$(zpool list -Ho freeing $pool)" ]] && break
3037                 log_must sleep 1
3038         done
3039 }
3040
3041 #
3042 # Wait for every device replace operation to complete
3043 #
3044 # $1 pool name
3045 #
3046 function wait_replacing #pool
3047 {
3048         typeset pool=${1:-$TESTPOOL}
3049         while true; do
3050                 [[ "" == "$(zpool status $pool |
3051                     awk '/replacing-[0-9]+/ {print $1}')" ]] && break
3052                 log_must sleep 1
3053         done
3054 }
3055
3056 #
3057 # Wait for a pool to be scrubbed
3058 #
3059 # $1 pool name
3060 # $2 number of seconds to wait (optional)
3061 #
3062 # Returns true when pool has been scrubbed, or false if there's a timeout or if
3063 # no scrub was done.
3064 #
3065 function wait_scrubbed
3066 {
3067         typeset pool=${1:-$TESTPOOL}
3068         typeset iter=${2:-10}
3069         for i in {1..$iter} ; do
3070                 if is_pool_scrubbed $pool ; then
3071                         return 0
3072                 fi
3073                 sleep 1
3074         done
3075         return 1
3076 }
3077
3078 #
3079 # Setup custom environment for the ZED.
3080 #
3081 # $@ Optional list of zedlets to run under zed.
3082 function zed_setup
3083 {
3084         if ! is_linux; then
3085                 return
3086         fi
3087
3088         if [[ ! -d $ZEDLET_DIR ]]; then
3089                 log_must mkdir $ZEDLET_DIR
3090         fi
3091
3092         if [[ ! -e $VDEVID_CONF ]]; then
3093                 log_must touch $VDEVID_CONF
3094         fi
3095
3096         if [[ -e $VDEVID_CONF_ETC ]]; then
3097                 log_fail "Must not have $VDEVID_CONF_ETC file present on system"
3098         fi
3099         EXTRA_ZEDLETS=$@
3100
3101         # Create a symlink for /etc/zfs/vdev_id.conf file.
3102         log_must ln -s $VDEVID_CONF $VDEVID_CONF_ETC
3103
3104         # Setup minimal ZED configuration.  Individual test cases should
3105         # add additional ZEDLETs as needed for their specific test.
3106         log_must cp ${ZEDLET_ETC_DIR}/zed.rc $ZEDLET_DIR
3107         log_must cp ${ZEDLET_ETC_DIR}/zed-functions.sh $ZEDLET_DIR
3108
3109         # Scripts must only be user writable.
3110         if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3111                 saved_umask=$(umask)
3112                 log_must umask 0022
3113                 for i in $EXTRA_ZEDLETS ; do
3114                         log_must cp ${ZEDLET_LIBEXEC_DIR}/$i $ZEDLET_DIR
3115                 done
3116                 log_must umask $saved_umask
3117         fi
3118
3119         # Customize the zed.rc file to enable the full debug log.
3120         log_must sed -i '/\#ZED_DEBUG_LOG=.*/d' $ZEDLET_DIR/zed.rc
3121         echo "ZED_DEBUG_LOG=$ZED_DEBUG_LOG" >>$ZEDLET_DIR/zed.rc
3122
3123 }
3124
3125 #
3126 # Cleanup custom ZED environment.
3127 #
3128 # $@ Optional list of zedlets to remove from our test zed.d directory.
3129 function zed_cleanup
3130 {
3131         if ! is_linux; then
3132                 return
3133         fi
3134         EXTRA_ZEDLETS=$@
3135
3136         log_must rm -f ${ZEDLET_DIR}/zed.rc
3137         log_must rm -f ${ZEDLET_DIR}/zed-functions.sh
3138         log_must rm -f ${ZEDLET_DIR}/all-syslog.sh
3139         log_must rm -f ${ZEDLET_DIR}/all-debug.sh
3140         log_must rm -f ${ZEDLET_DIR}/state
3141
3142         if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3143                 for i in $EXTRA_ZEDLETS ; do
3144                         log_must rm -f ${ZEDLET_DIR}/$i
3145                 done
3146         fi
3147         log_must rm -f $ZED_LOG
3148         log_must rm -f $ZED_DEBUG_LOG
3149         log_must rm -f $VDEVID_CONF_ETC
3150         log_must rm -f $VDEVID_CONF
3151         rmdir $ZEDLET_DIR
3152 }
3153
3154 #
3155 # Check if ZED is currently running, if not start ZED.
3156 #
3157 function zed_start
3158 {
3159         if ! is_linux; then
3160                 return
3161         fi
3162
3163         # ZEDLET_DIR=/var/tmp/zed
3164         if [[ ! -d $ZEDLET_DIR ]]; then
3165                 log_must mkdir $ZEDLET_DIR
3166         fi
3167
3168         # Verify the ZED is not already running.
3169         pgrep -x zed > /dev/null
3170         if (($? == 0)); then
3171                 log_fail "ZED already running"
3172         fi
3173
3174         log_note "Starting ZED"
3175         # run ZED in the background and redirect foreground logging
3176         # output to $ZED_LOG.
3177         log_must truncate -s 0 $ZED_DEBUG_LOG
3178         log_must eval "zed -vF -d $ZEDLET_DIR -p $ZEDLET_DIR/zed.pid -P $PATH" \
3179             "-s $ZEDLET_DIR/state 2>$ZED_LOG &"
3180
3181         return 0
3182 }
3183
3184 #
3185 # Kill ZED process
3186 #
3187 function zed_stop
3188 {
3189         if ! is_linux; then
3190                 return
3191         fi
3192
3193         log_note "Stopping ZED"
3194         if [[ -f ${ZEDLET_DIR}/zed.pid ]]; then
3195                 zedpid=$(cat ${ZEDLET_DIR}/zed.pid)
3196                 kill $zedpid
3197                 while ps -p $zedpid > /dev/null; do
3198                         sleep 1
3199                 done
3200                 rm -f ${ZEDLET_DIR}/zed.pid
3201         fi
3202         return 0
3203 }
3204
3205 #
3206 # Drain all zevents
3207 #
3208 function zed_events_drain
3209 {
3210         while [ $(zpool events -H | wc -l) -ne 0 ]; do
3211                 sleep 1
3212                 zpool events -c >/dev/null
3213         done
3214 }
3215
3216 #
3217 # Check is provided device is being active used as a swap device.
3218 #
3219 function is_swap_inuse
3220 {
3221         typeset device=$1
3222
3223         if [[ -z $device ]] ; then
3224                 log_note "No device specified."
3225                 return 1
3226         fi
3227
3228         if is_linux; then
3229                 swapon -s | grep -w $(readlink -f $device) > /dev/null 2>&1
3230         else
3231                 swap -l | grep -w $device > /dev/null 2>&1
3232         fi
3233
3234         return $?
3235 }
3236
3237 #
3238 # Setup a swap device using the provided device.
3239 #
3240 function swap_setup
3241 {
3242         typeset swapdev=$1
3243
3244         if is_linux; then
3245                 log_must eval "mkswap $swapdev > /dev/null 2>&1"
3246                 log_must swapon $swapdev
3247         else
3248                 log_must swap -a $swapdev
3249         fi
3250
3251         return 0
3252 }
3253
3254 #
3255 # Cleanup a swap device on the provided device.
3256 #
3257 function swap_cleanup
3258 {
3259         typeset swapdev=$1
3260
3261         if is_swap_inuse $swapdev; then
3262                 if is_linux; then
3263                         log_must swapoff $swapdev
3264                 else
3265                         log_must swap -d $swapdev
3266                 fi
3267         fi
3268
3269         return 0
3270 }
3271
3272 #
3273 # Set a global system tunable (64-bit value)
3274 #
3275 # $1 tunable name
3276 # $2 tunable values
3277 #
3278 function set_tunable64
3279 {
3280         set_tunable_impl "$1" "$2" Z
3281 }
3282
3283 #
3284 # Set a global system tunable (32-bit value)
3285 #
3286 # $1 tunable name
3287 # $2 tunable values
3288 #
3289 function set_tunable32
3290 {
3291         set_tunable_impl "$1" "$2" W
3292 }
3293
3294 function set_tunable_impl
3295 {
3296         typeset tunable="$1"
3297         typeset value="$2"
3298         typeset mdb_cmd="$3"
3299         typeset module="${4:-zfs}"
3300
3301         [[ -z "$tunable" ]] && return 1
3302         [[ -z "$value" ]] && return 1
3303         [[ -z "$mdb_cmd" ]] && return 1
3304
3305         case "$(uname)" in
3306         Linux)
3307                 typeset zfs_tunables="/sys/module/$module/parameters"
3308                 [[ -w "$zfs_tunables/$tunable" ]] || return 1
3309                 echo -n "$value" > "$zfs_tunables/$tunable"
3310                 return "$?"
3311                 ;;
3312         SunOS)
3313                 [[ "$module" -eq "zfs" ]] || return 1
3314                 echo "${tunable}/${mdb_cmd}0t${value}" | mdb -kw
3315                 return "$?"
3316                 ;;
3317         esac
3318 }
3319
3320 #
3321 # Get a global system tunable
3322 #
3323 # $1 tunable name
3324 #
3325 function get_tunable
3326 {
3327         get_tunable_impl "$1"
3328 }
3329
3330 function get_tunable_impl
3331 {
3332         typeset tunable="$1"
3333         typeset module="${2:-zfs}"
3334
3335         [[ -z "$tunable" ]] && return 1
3336
3337         case "$(uname)" in
3338         Linux)
3339                 typeset zfs_tunables="/sys/module/$module/parameters"
3340                 [[ -f "$zfs_tunables/$tunable" ]] || return 1
3341                 cat $zfs_tunables/$tunable
3342                 return "$?"
3343                 ;;
3344         SunOS)
3345                 [[ "$module" -eq "zfs" ]] || return 1
3346                 ;;
3347         esac
3348
3349         return 1
3350 }