4 # The contents of this file are subject to the terms of the
5 # Common Development and Distribution License (the "License").
6 # You may not use this file except in compliance with the License.
8 # You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 # or http://www.opensolaris.org/os/licensing.
10 # See the License for the specific language governing permissions
11 # and limitations under the License.
13 # When distributing Covered Code, include this CDDL HEADER in each
14 # file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 # If applicable, add the following below this CDDL HEADER, with the
16 # fields enclosed by brackets "[]" replaced with your own identifying
17 # information: Portions Copyright [yyyy] [name of copyright owner]
23 # Copyright 2009 Sun Microsystems, Inc. All rights reserved.
24 # Use is subject to license terms.
28 # Copyright (c) 2012, 2015 by Delphix. All rights reserved.
31 . ${STF_TOOLS}/contrib/include/logapi.shlib
33 ZFS=${ZFS:-/usr/sbin/zfs}
34 ZPOOL=${ZPOOL:-/usr/sbin/zpool}
36 # Determine whether a dataset is mounted
39 # $2 filesystem type; optional - defaulted to zfs
41 # Return 0 if dataset is mounted; 1 if unmounted; 2 on error
46 [[ -z $fstype ]] && fstype=zfs
47 typeset out dir name ret
51 if [[ "$1" == "/"* ]] ; then
52 for out in $($ZFS mount | $AWK '{print $2}'); do
53 [[ $1 == $out ]] && return 0
56 for out in $($ZFS mount | $AWK '{print $1}'); do
57 [[ $1 == $out ]] && return 0
62 out=$($DF -F $fstype $1 2>/dev/null)
64 (($ret != 0)) && return $ret
72 [[ "$1" == "$dir" || "$1" == "$name" ]] && return 0
79 # Return 0 if a dataset is mounted; 1 otherwise
82 # $2 filesystem type; optional - defaulted to zfs
87 (($? == 0)) && return 0
91 # Return 0 if a dataset is unmounted; 1 otherwise
94 # $2 filesystem type; optional - defaulted to zfs
99 (($? == 1)) && return 0
109 $ECHO $1 | $SED "s/,/ /g"
112 function default_setup
114 default_setup_noexit "$@"
120 # Given a list of disks, setup storage pools and datasets.
122 function default_setup_noexit
128 if is_global_zone; then
129 if poolexists $TESTPOOL ; then
130 destroy_pool $TESTPOOL
132 [[ -d /$TESTPOOL ]] && $RM -rf /$TESTPOOL
133 log_must $ZPOOL create -f $TESTPOOL $disklist
138 $RM -rf $TESTDIR || log_unresolved Could not remove $TESTDIR
139 $MKDIR -p $TESTDIR || log_unresolved Could not create $TESTDIR
141 log_must $ZFS create $TESTPOOL/$TESTFS
142 log_must $ZFS set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
144 if [[ -n $container ]]; then
145 $RM -rf $TESTDIR1 || \
146 log_unresolved Could not remove $TESTDIR1
147 $MKDIR -p $TESTDIR1 || \
148 log_unresolved Could not create $TESTDIR1
150 log_must $ZFS create $TESTPOOL/$TESTCTR
151 log_must $ZFS set canmount=off $TESTPOOL/$TESTCTR
152 log_must $ZFS create $TESTPOOL/$TESTCTR/$TESTFS1
153 log_must $ZFS set mountpoint=$TESTDIR1 \
154 $TESTPOOL/$TESTCTR/$TESTFS1
157 if [[ -n $volume ]]; then
158 if is_global_zone ; then
159 log_must $ZFS create -V $VOLSIZE $TESTPOOL/$TESTVOL
161 log_must $ZFS create $TESTPOOL/$TESTVOL
167 # Given a list of disks, setup a storage pool, file system and
170 function default_container_setup
174 default_setup "$disklist" "true"
178 # Given a list of disks, setup a storage pool,file system
181 function default_volume_setup
185 default_setup "$disklist" "" "true"
189 # Given a list of disks, setup a storage pool,file system,
190 # a container and a volume.
192 function default_container_volume_setup
196 default_setup "$disklist" "true" "true"
200 # Create a snapshot on a filesystem or volume. Defaultly create a snapshot on
203 # $1 Existing filesystem or volume name. Default, $TESTFS
204 # $2 snapshot name. Default, $TESTSNAP
206 function create_snapshot
208 typeset fs_vol=${1:-$TESTFS}
209 typeset snap=${2:-$TESTSNAP}
211 [[ -z $fs_vol ]] && log_fail "Filesystem or volume's name is undefined."
212 [[ -z $snap ]] && log_fail "Snapshot's name is undefined."
214 if snapexists $fs_vol@$snap; then
215 log_fail "$fs_vol@$snap already exists."
217 datasetexists $fs_vol || \
218 log_fail "$fs_vol must exist."
220 log_must $ZFS snapshot $fs_vol@$snap
224 # Create a clone from a snapshot, default clone name is $TESTCLONE.
226 # $1 Existing snapshot, $TESTPOOL/$TESTFS@$TESTSNAP is default.
227 # $2 Clone name, $TESTPOOL/$TESTCLONE is default.
229 function create_clone # snapshot clone
231 typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
232 typeset clone=${2:-$TESTPOOL/$TESTCLONE}
235 log_fail "Snapshot name is undefined."
237 log_fail "Clone name is undefined."
239 log_must $ZFS clone $snap $clone
242 function default_mirror_setup
244 default_mirror_setup_noexit $1 $2 $3
250 # Given a pair of disks, set up a storage pool and dataset for the mirror
251 # @parameters: $1 the primary side of the mirror
252 # $2 the secondary side of the mirror
253 # @uses: ZPOOL ZFS TESTPOOL TESTFS
254 function default_mirror_setup_noexit
256 readonly func="default_mirror_setup_noexit"
260 [[ -z $primary ]] && \
261 log_fail "$func: No parameters passed"
262 [[ -z $secondary ]] && \
263 log_fail "$func: No secondary partition passed"
264 [[ -d /$TESTPOOL ]] && $RM -rf /$TESTPOOL
265 log_must $ZPOOL create -f $TESTPOOL mirror $@
266 log_must $ZFS create $TESTPOOL/$TESTFS
267 log_must $ZFS set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
271 # create a number of mirrors.
272 # We create a number($1) of 2 way mirrors using the pairs of disks named
273 # on the command line. These mirrors are *not* mounted
274 # @parameters: $1 the number of mirrors to create
275 # $... the devices to use to create the mirrors on
276 # @uses: ZPOOL ZFS TESTPOOL
277 function setup_mirrors
279 typeset -i nmirrors=$1
282 while ((nmirrors > 0)); do
283 log_must test -n "$1" -a -n "$2"
284 [[ -d /$TESTPOOL$nmirrors ]] && $RM -rf /$TESTPOOL$nmirrors
285 log_must $ZPOOL create -f $TESTPOOL$nmirrors mirror $1 $2
287 ((nmirrors = nmirrors - 1))
292 # create a number of raidz pools.
293 # We create a number($1) of 2 raidz pools using the pairs of disks named
294 # on the command line. These pools are *not* mounted
295 # @parameters: $1 the number of pools to create
296 # $... the devices to use to create the pools on
297 # @uses: ZPOOL ZFS TESTPOOL
298 function setup_raidzs
300 typeset -i nraidzs=$1
303 while ((nraidzs > 0)); do
304 log_must test -n "$1" -a -n "$2"
305 [[ -d /$TESTPOOL$nraidzs ]] && $RM -rf /$TESTPOOL$nraidzs
306 log_must $ZPOOL create -f $TESTPOOL$nraidzs raidz $1 $2
308 ((nraidzs = nraidzs - 1))
313 # Destroy the configured testpool mirrors.
314 # the mirrors are of the form ${TESTPOOL}{number}
315 # @uses: ZPOOL ZFS TESTPOOL
316 function destroy_mirrors
318 default_cleanup_noexit
324 # Given a minimum of two disks, set up a storage pool and dataset for the raid-z
325 # $1 the list of disks
327 function default_raidz_setup
329 typeset disklist="$*"
330 disks=(${disklist[*]})
332 if [[ ${#disks[*]} -lt 2 ]]; then
333 log_fail "A raid-z requires a minimum of two disks."
336 [[ -d /$TESTPOOL ]] && $RM -rf /$TESTPOOL
337 log_must $ZPOOL create -f $TESTPOOL raidz $1 $2 $3
338 log_must $ZFS create $TESTPOOL/$TESTFS
339 log_must $ZFS set mountpoint=$TESTDIR $TESTPOOL/$TESTFS
345 # Common function used to cleanup storage pools and datasets.
347 # Invoked at the start of the test suite to ensure the system
348 # is in a known state, and also at the end of each set of
349 # sub-tests to ensure errors from one set of tests doesn't
350 # impact the execution of the next set.
352 function default_cleanup
354 default_cleanup_noexit
359 function default_cleanup_noexit
364 # Destroying the pool will also destroy any
365 # filesystems it contains.
367 if is_global_zone; then
368 $ZFS unmount -a > /dev/null 2>&1
369 exclude=`eval $ECHO \"'(${KEEP})'\"`
370 ALL_POOLS=$($ZPOOL list -H -o name \
371 | $GREP -v "$NO_POOLS" | $EGREP -v "$exclude")
372 # Here, we loop through the pools we're allowed to
373 # destroy, only destroying them if it's safe to do
375 while [ ! -z ${ALL_POOLS} ]
377 for pool in ${ALL_POOLS}
379 if safe_to_destroy_pool $pool ;
383 ALL_POOLS=$($ZPOOL list -H -o name \
384 | $GREP -v "$NO_POOLS" \
385 | $EGREP -v "$exclude")
392 for fs in $($ZFS list -H -o name \
393 | $GREP "^$ZONE_POOL/$ZONE_CTR[01234]/"); do
394 datasetexists $fs && \
395 log_must $ZFS destroy -Rf $fs
398 # Need cleanup here to avoid garbage dir left.
399 for fs in $($ZFS list -H -o name); do
400 [[ $fs == /$ZONE_POOL ]] && continue
401 [[ -d $fs ]] && log_must $RM -rf $fs/*
405 # Reset the $ZONE_POOL/$ZONE_CTR[01234] file systems property to
408 for fs in $($ZFS list -H -o name); do
409 if [[ $fs == $ZONE_POOL/$ZONE_CTR[01234] ]]; then
410 log_must $ZFS set reservation=none $fs
411 log_must $ZFS set recordsize=128K $fs
412 log_must $ZFS set mountpoint=/$fs $fs
414 enc=$(get_prop encryption $fs)
415 if [[ $? -ne 0 ]] || [[ -z "$enc" ]] || \
416 [[ "$enc" == "off" ]]; then
417 log_must $ZFS set checksum=on $fs
419 log_must $ZFS set compression=off $fs
420 log_must $ZFS set atime=on $fs
421 log_must $ZFS set devices=off $fs
422 log_must $ZFS set exec=on $fs
423 log_must $ZFS set setuid=on $fs
424 log_must $ZFS set readonly=off $fs
425 log_must $ZFS set snapdir=hidden $fs
426 log_must $ZFS set aclmode=groupmask $fs
427 log_must $ZFS set aclinherit=secure $fs
432 [[ -d $TESTDIR ]] && \
433 log_must $RM -rf $TESTDIR
438 # Common function used to cleanup storage pools, file systems
441 function default_container_cleanup
443 if ! is_global_zone; then
447 ismounted $TESTPOOL/$TESTCTR/$TESTFS1
449 log_must $ZFS unmount $TESTPOOL/$TESTCTR/$TESTFS1
451 datasetexists $TESTPOOL/$TESTCTR/$TESTFS1 && \
452 log_must $ZFS destroy -R $TESTPOOL/$TESTCTR/$TESTFS1
454 datasetexists $TESTPOOL/$TESTCTR && \
455 log_must $ZFS destroy -Rf $TESTPOOL/$TESTCTR
457 [[ -e $TESTDIR1 ]] && \
458 log_must $RM -rf $TESTDIR1 > /dev/null 2>&1
464 # Common function used to cleanup snapshot of file system or volume. Default to
465 # delete the file system's snapshot
469 function destroy_snapshot
471 typeset snap=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
473 if ! snapexists $snap; then
474 log_fail "'$snap' does not existed."
478 # For the sake of the value which come from 'get_prop' is not equal
479 # to the really mountpoint when the snapshot is unmounted. So, firstly
480 # check and make sure this snapshot's been mounted in current system.
483 if ismounted $snap; then
484 mtpt=$(get_prop mountpoint $snap)
486 log_fail "get_prop mountpoint $snap failed."
489 log_must $ZFS destroy $snap
490 [[ $mtpt != "" && -d $mtpt ]] && \
491 log_must $RM -rf $mtpt
495 # Common function used to cleanup clone.
499 function destroy_clone
501 typeset clone=${1:-$TESTPOOL/$TESTCLONE}
503 if ! datasetexists $clone; then
504 log_fail "'$clone' does not existed."
507 # With the same reason in destroy_snapshot
509 if ismounted $clone; then
510 mtpt=$(get_prop mountpoint $clone)
512 log_fail "get_prop mountpoint $clone failed."
515 log_must $ZFS destroy $clone
516 [[ $mtpt != "" && -d $mtpt ]] && \
517 log_must $RM -rf $mtpt
520 # Return 0 if a snapshot exists; $? otherwise
526 $ZFS list -H -t snapshot "$1" > /dev/null 2>&1
531 # Set a property to a certain value on a dataset.
532 # Sets a property of the dataset to the value as passed in.
534 # $1 dataset who's property is being set
536 # $3 value to set property to
538 # 0 if the property could be set.
539 # non-zero otherwise.
542 function dataset_setprop
544 typeset fn=dataset_setprop
547 log_note "$fn: Insufficient parameters (need 3, had $#)"
551 output=$($ZFS set $2=$3 $1 2>&1)
554 log_note "Setting property on $1 failed."
555 log_note "property $2=$3"
556 log_note "Return Code: $rv"
557 log_note "Output: $output"
564 # Assign suite defined dataset properties.
565 # This function is used to apply the suite's defined default set of
566 # properties to a dataset.
567 # @parameters: $1 dataset to use
568 # @uses: ZFS COMPRESSION_PROP CHECKSUM_PROP
570 # 0 if the dataset has been altered.
571 # 1 if no pool name was passed in.
572 # 2 if the dataset could not be found.
573 # 3 if the dataset could not have it's properties set.
575 function dataset_set_defaultproperties
579 [[ -z $dataset ]] && return 1
583 for confset in $($ZFS list); do
584 if [[ $dataset = $confset ]]; then
589 [[ $found -eq 0 ]] && return 2
590 if [[ -n $COMPRESSION_PROP ]]; then
591 dataset_setprop $dataset compression $COMPRESSION_PROP || \
593 log_note "Compression set to '$COMPRESSION_PROP' on $dataset"
595 if [[ -n $CHECKSUM_PROP ]]; then
596 dataset_setprop $dataset checksum $CHECKSUM_PROP || \
598 log_note "Checksum set to '$CHECKSUM_PROP' on $dataset"
604 # Check a numeric assertion
605 # @parameter: $@ the assertion to check
606 # @output: big loud notice if assertion failed
611 (($@)) || log_fail "$@"
615 # Function to format partition size of a disk
616 # Given a disk cxtxdx reduces all partitions
619 function zero_partitions #<whole_disk_name>
624 for i in 0 1 3 4 5 6 7
626 set_partition $i "" 0mb $diskname
631 # Given a slice, size and disk, this function
632 # formats the slice to the specified size.
633 # Size should be specified with units as per
634 # the `format` command requirements eg. 100mb 3gb
636 function set_partition #<slice_num> <slice_start> <size_plus_units> <whole_disk_name>
638 typeset -i slicenum=$1
642 [[ -z $slicenum || -z $size || -z $disk ]] && \
643 log_fail "The slice, size or disk name is unspecified."
644 typeset format_file=/var/tmp/format_in.$$
646 $ECHO "partition" >$format_file
647 $ECHO "$slicenum" >> $format_file
648 $ECHO "" >> $format_file
649 $ECHO "" >> $format_file
650 $ECHO "$start" >> $format_file
651 $ECHO "$size" >> $format_file
652 $ECHO "label" >> $format_file
653 $ECHO "" >> $format_file
654 $ECHO "q" >> $format_file
655 $ECHO "q" >> $format_file
657 $FORMAT -e -s -d $disk -f $format_file
660 [[ $ret_val -ne 0 ]] && \
661 log_fail "Unable to format $disk slice $slicenum to $size"
666 # Get the end cyl of the given slice
668 function get_endslice #<disk> <slice>
672 if [[ -z $disk || -z $slice ]] ; then
673 log_fail "The disk name or slice number is unspecified."
676 disk=${disk#/dev/dsk/}
677 disk=${disk#/dev/rdsk/}
681 ratio=$($PRTVTOC /dev/rdsk/${disk}s2 | \
682 $GREP "sectors\/cylinder" | \
685 if ((ratio == 0)); then
689 typeset -i endcyl=$($PRTVTOC -h /dev/rdsk/${disk}s2 |
690 $NAWK -v token="$slice" '{if ($1==token) print $6}')
692 ((endcyl = (endcyl + 1) / ratio))
698 # Given a size,disk and total slice number, this function formats the
699 # disk slices from 0 to the total slice number with the same specified
702 function partition_disk #<slice_size> <whole_disk_name> <total_slices>
705 typeset slice_size=$1
707 typeset total_slices=$3
710 zero_partitions $disk_name
711 while ((i < $total_slices)); do
716 set_partition $i "$cyl" $slice_size $disk_name
717 cyl=$(get_endslice $disk_name $i)
723 # This function continues to write to a filenum number of files into dirnum
724 # number of directories until either $FILE_WRITE returns an error or the
725 # maximum number of files per directory have been written.
728 # fill_fs [destdir] [dirnum] [filenum] [bytes] [num_writes] [data]
730 # Return value: 0 on success
734 # destdir: is the directory where everything is to be created under
735 # dirnum: the maximum number of subdirectories to use, -1 no limit
736 # filenum: the maximum number of files per subdirectory
737 # bytes: number of bytes to write
738 # num_writes: numer of types to write out bytes
739 # data: the data that will be writen
742 # file_fs /testdir 20 25 1024 256 0
744 # Note: bytes * num_writes equals the size of the testfile
746 function fill_fs # destdir dirnum filenum bytes num_writes data
748 typeset destdir=${1:-$TESTDIR}
749 typeset -i dirnum=${2:-50}
750 typeset -i filenum=${3:-50}
751 typeset -i bytes=${4:-8192}
752 typeset -i num_writes=${5:-10240}
753 typeset -i data=${6:-0}
760 log_must $MKDIR -p $destdir/$idirnum
761 while (($odirnum > 0)); do
762 if ((dirnum >= 0 && idirnum >= dirnum)); then
766 $FILE_WRITE -o create -f $destdir/$idirnum/$TESTFILE.$fn \
767 -b $bytes -c $num_writes -d $data
769 if (($retval != 0)); then
773 if (($fn >= $filenum)); then
775 ((idirnum = idirnum + 1))
776 log_must $MKDIR -p $destdir/$idirnum
785 # Simple function to get the specified property. If unable to
786 # get the property then exits.
788 # Note property is in 'parsable' format (-p)
790 function get_prop # property dataset
796 prop_val=$($ZFS get -pH -o value $prop $dataset 2>/dev/null)
797 if [[ $? -ne 0 ]]; then
798 log_note "Unable to get $prop property for dataset " \
808 # Simple function to get the specified property of pool. If unable to
809 # get the property then exits.
811 function get_pool_prop # property pool
817 if poolexists $pool ; then
818 prop_val=$($ZPOOL get $prop $pool 2>/dev/null | $TAIL -1 | \
820 if [[ $? -ne 0 ]]; then
821 log_note "Unable to get $prop property for pool " \
826 log_note "Pool $pool not exists."
834 # Return 0 if a pool exists; $? otherwise
842 if [[ -z $pool ]]; then
843 log_note "No pool name given."
847 $ZPOOL get name "$pool" > /dev/null 2>&1
851 # Return 0 if all the specified datasets exist; $? otherwise
854 function datasetexists
857 log_note "No dataset name given."
862 $ZFS get name $1 > /dev/null 2>&1 || \
870 # return 0 if none of the specified datasets exists, otherwise return 1.
873 function datasetnonexists
876 log_note "No dataset name given."
881 $ZFS list -H -t filesystem,snapshot,volume $1 > /dev/null 2>&1 \
890 # Given a mountpoint, or a dataset name, determine if it is shared.
892 # Returns 0 if shared, 1 otherwise.
899 if [[ $fs != "/"* ]] ; then
900 if datasetnonexists "$fs" ; then
903 mtpt=$(get_prop mountpoint "$fs")
905 none|legacy|-) return 1
913 for mtpt in `$SHARE | $AWK '{print $2}'` ; do
914 if [[ $mtpt == $fs ]] ; then
919 typeset stat=$($SVCS -H -o STA nfs/server:default)
920 if [[ $stat != "ON" ]]; then
921 log_note "Current nfs/server status: $stat"
928 # Given a mountpoint, determine if it is not shared.
930 # Returns 0 if not shared, 1 otherwise.
945 # Helper function to unshare a mountpoint.
947 function unshare_fs #fs
953 log_must $ZFS unshare $fs
960 # Check NFS server status and trigger it online.
962 function setup_nfs_server
964 # Cannot share directory in non-global zone.
966 if ! is_global_zone; then
967 log_note "Cannot trigger NFS server by sharing in LZ."
971 typeset nfs_fmri="svc:/network/nfs/server:default"
972 if [[ $($SVCS -Ho STA $nfs_fmri) != "ON" ]]; then
974 # Only really sharing operation can enable NFS server
975 # to online permanently.
977 typeset dummy=/tmp/dummy
979 if [[ -d $dummy ]]; then
980 log_must $RM -rf $dummy
983 log_must $MKDIR $dummy
984 log_must $SHARE $dummy
987 # Waiting for fmri's status to be the final status.
988 # Otherwise, in transition, an asterisk (*) is appended for
989 # instances, unshare will reverse status to 'DIS' again.
991 # Waiting for 1's at least.
995 while [[ timeout -ne 0 && $($SVCS -Ho STA $nfs_fmri) == *'*' ]]
1002 log_must $UNSHARE $dummy
1003 log_must $RM -rf $dummy
1006 log_note "Current NFS status: '$($SVCS -Ho STA,FMRI $nfs_fmri)'"
1010 # To verify whether calling process is in global zone
1012 # Return 0 if in global zone, 1 in non-global zone
1014 function is_global_zone
1016 typeset cur_zone=$($ZONENAME 2>/dev/null)
1017 if [[ $cur_zone != "global" ]]; then
1024 # Verify whether test is permitted to run from
1025 # global zone, local zone, or both
1027 # $1 zone limit, could be "global", "local", or "both"(no limit)
1029 # Return 0 if permitted, otherwise exit with log_unsupported
1031 function verify_runnable # zone limit
1035 [[ -z $limit ]] && return 0
1037 if is_global_zone ; then
1041 local) log_unsupported "Test is unable to run from "\
1044 *) log_note "Warning: unknown limit $limit - " \
1052 global) log_unsupported "Test is unable to run from "\
1055 *) log_note "Warning: unknown limit $limit - " \
1066 # Return 0 if create successfully or the pool exists; $? otherwise
1067 # Note: In local zones, this function should return 0 silently.
1070 # $2-n - [keyword] devs_list
1072 function create_pool #pool devs_list
1074 typeset pool=${1%%/*}
1078 if [[ -z $pool ]]; then
1079 log_note "Missing pool name."
1083 if poolexists $pool ; then
1087 if is_global_zone ; then
1088 [[ -d /$pool ]] && $RM -rf /$pool
1089 log_must $ZPOOL create -f $pool $@
1095 # Return 0 if destroy successfully or the pool exists; $? otherwise
1096 # Note: In local zones, this function should return 0 silently.
1099 # Destroy pool with the given parameters.
1101 function destroy_pool #pool
1103 typeset pool=${1%%/*}
1106 if [[ -z $pool ]]; then
1107 log_note "No pool name given."
1111 if is_global_zone ; then
1112 if poolexists "$pool" ; then
1113 mtpt=$(get_prop mountpoint "$pool")
1115 # At times, syseventd activity can cause attempts to
1116 # destroy a pool to fail with EBUSY. We retry a few
1117 # times allowing failures before requiring the destroy
1119 typeset -i wait_time=10 ret=1 count=0
1121 while [[ $ret -ne 0 ]]; do
1122 $must $ZPOOL destroy -f $pool
1124 [[ $ret -eq 0 ]] && break
1125 log_note "zpool destroy failed with $ret"
1126 [[ count++ -ge 7 ]] && must=log_must
1131 log_must $RM -rf $mtpt
1133 log_note "Pool does not exist. ($pool)"
1142 # Firstly, create a pool with 5 datasets. Then, create a single zone and
1143 # export the 5 datasets to it. In addition, we also add a ZFS filesystem
1144 # and a zvol device to the zone.
1147 # $2 zone root directory prefix
1150 function zfs_zones_setup #zone_name zone_root zone_ip
1152 typeset zone_name=${1:-$(hostname)-z}
1153 typeset zone_root=${2:-"/zone_root"}
1154 typeset zone_ip=${3:-"10.1.1.10"}
1155 typeset prefix_ctr=$ZONE_CTR
1156 typeset pool_name=$ZONE_POOL
1160 # Create pool and 5 container within it
1162 [[ -d /$pool_name ]] && $RM -rf /$pool_name
1163 log_must $ZPOOL create -f $pool_name $DISKS
1164 while ((i < cntctr)); do
1165 log_must $ZFS create $pool_name/$prefix_ctr$i
1170 log_must $ZFS create -V 1g $pool_name/zone_zvol
1173 # If current system support slog, add slog device for pool
1175 if verify_slog_support ; then
1176 typeset sdevs="/var/tmp/sdev1 /var/tmp/sdev2"
1177 log_must $MKFILE 100M $sdevs
1178 log_must $ZPOOL add $pool_name log mirror $sdevs
1181 # this isn't supported just yet.
1182 # Create a filesystem. In order to add this to
1183 # the zone, it must have it's mountpoint set to 'legacy'
1184 # log_must $ZFS create $pool_name/zfs_filesystem
1185 # log_must $ZFS set mountpoint=legacy $pool_name/zfs_filesystem
1187 [[ -d $zone_root ]] && \
1188 log_must $RM -rf $zone_root/$zone_name
1189 [[ ! -d $zone_root ]] && \
1190 log_must $MKDIR -p -m 0700 $zone_root/$zone_name
1192 # Create zone configure file and configure the zone
1194 typeset zone_conf=/tmp/zone_conf.$$
1195 $ECHO "create" > $zone_conf
1196 $ECHO "set zonepath=$zone_root/$zone_name" >> $zone_conf
1197 $ECHO "set autoboot=true" >> $zone_conf
1199 while ((i < cntctr)); do
1200 $ECHO "add dataset" >> $zone_conf
1201 $ECHO "set name=$pool_name/$prefix_ctr$i" >> \
1203 $ECHO "end" >> $zone_conf
1207 # add our zvol to the zone
1208 $ECHO "add device" >> $zone_conf
1209 $ECHO "set match=/dev/zvol/dsk/$pool_name/zone_zvol" >> $zone_conf
1210 $ECHO "end" >> $zone_conf
1212 # add a corresponding zvol rdsk to the zone
1213 $ECHO "add device" >> $zone_conf
1214 $ECHO "set match=/dev/zvol/rdsk/$pool_name/zone_zvol" >> $zone_conf
1215 $ECHO "end" >> $zone_conf
1217 # once it's supported, we'll add our filesystem to the zone
1218 # $ECHO "add fs" >> $zone_conf
1219 # $ECHO "set type=zfs" >> $zone_conf
1220 # $ECHO "set special=$pool_name/zfs_filesystem" >> $zone_conf
1221 # $ECHO "set dir=/export/zfs_filesystem" >> $zone_conf
1222 # $ECHO "end" >> $zone_conf
1224 $ECHO "verify" >> $zone_conf
1225 $ECHO "commit" >> $zone_conf
1226 log_must $ZONECFG -z $zone_name -f $zone_conf
1227 log_must $RM -f $zone_conf
1230 $ZONEADM -z $zone_name install
1231 if (($? == 0)); then
1232 log_note "SUCCESS: $ZONEADM -z $zone_name install"
1234 log_fail "FAIL: $ZONEADM -z $zone_name install"
1237 # Install sysidcfg file
1239 typeset sysidcfg=$zone_root/$zone_name/root/etc/sysidcfg
1240 $ECHO "system_locale=C" > $sysidcfg
1241 $ECHO "terminal=dtterm" >> $sysidcfg
1242 $ECHO "network_interface=primary {" >> $sysidcfg
1243 $ECHO "hostname=$zone_name" >> $sysidcfg
1244 $ECHO "}" >> $sysidcfg
1245 $ECHO "name_service=NONE" >> $sysidcfg
1246 $ECHO "root_password=mo791xfZ/SFiw" >> $sysidcfg
1247 $ECHO "security_policy=NONE" >> $sysidcfg
1248 $ECHO "timezone=US/Eastern" >> $sysidcfg
1251 log_must $ZONEADM -z $zone_name boot
1255 # Reexport TESTPOOL & TESTPOOL(1-4)
1257 function reexport_pool
1262 while ((i < cntctr)); do
1264 TESTPOOL=$ZONE_POOL/$ZONE_CTR$i
1265 if ! ismounted $TESTPOOL; then
1266 log_must $ZFS mount $TESTPOOL
1269 eval TESTPOOL$i=$ZONE_POOL/$ZONE_CTR$i
1270 if eval ! ismounted \$TESTPOOL$i; then
1271 log_must eval $ZFS mount \$TESTPOOL$i
1279 # Verify a given disk is online or offline
1281 # Return 0 is pool/disk matches expected state, 1 otherwise
1283 function check_state # pool disk state{online,offline}
1286 typeset disk=${2#/dev/dsk/}
1289 $ZPOOL status -v $pool | grep "$disk" \
1290 | grep -i "$state" > /dev/null 2>&1
1296 # Get the mountpoint of snapshot
1297 # For the snapshot use <mp_filesystem>/.zfs/snapshot/<snap>
1300 function snapshot_mountpoint
1302 typeset dataset=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
1304 if [[ $dataset != *@* ]]; then
1305 log_fail "Error name of snapshot '$dataset'."
1308 typeset fs=${dataset%@*}
1309 typeset snap=${dataset#*@}
1311 if [[ -z $fs || -z $snap ]]; then
1312 log_fail "Error name of snapshot '$dataset'."
1315 $ECHO $(get_prop mountpoint $fs)/.zfs/snapshot/$snap
1319 # Given a pool and file system, this function will verify the file system
1320 # using the zdb internal tool. Note that the pool is exported and imported
1321 # to ensure it has consistent state.
1323 function verify_filesys # pool filesystem dir
1326 typeset filesys="$2"
1327 typeset zdbout="/tmp/zdbout.$$"
1332 typeset search_path=""
1334 log_note "Calling $ZDB to verify filesystem '$filesys'"
1335 $ZFS unmount -a > /dev/null 2>&1
1336 log_must $ZPOOL export $pool
1338 if [[ -n $dirs ]] ; then
1339 for dir in $dirs ; do
1340 search_path="$search_path -d $dir"
1344 log_must $ZPOOL import $search_path $pool
1346 $ZDB -cudi $filesys > $zdbout 2>&1
1347 if [[ $? != 0 ]]; then
1348 log_note "Output: $ZDB -cudi $filesys"
1350 log_fail "$ZDB detected errors with: '$filesys'"
1353 log_must $ZFS mount -a
1354 log_must $RM -rf $zdbout
1358 # Given a pool, and this function list all disks in the pool
1360 function get_disklist # pool
1364 disklist=$($ZPOOL iostat -v $1 | $NAWK '(NR >4) {print $1}' | \
1365 $GREP -v "\-\-\-\-\-" | \
1366 $EGREP -v -e "^(mirror|raidz1|raidz2|spare|log|cache)$")
1372 # This function kills a given list of processes after a time period. We use
1373 # this in the stress tests instead of STF_TIMEOUT so that we can have processes
1374 # run for a fixed amount of time, yet still pass. Tests that hit STF_TIMEOUT
1375 # would be listed as FAIL, which we don't want : we're happy with stress tests
1376 # running for a certain amount of time, then finishing.
1378 # @param $1 the time in seconds after which we should terminate these processes
1379 # @param $2..$n the processes we wish to terminate.
1381 function stress_timeout
1383 typeset -i TIMEOUT=$1
1387 log_note "Waiting for child processes($cpids). " \
1388 "It could last dozens of minutes, please be patient ..."
1389 log_must $SLEEP $TIMEOUT
1391 log_note "Killing child processes after ${TIMEOUT} stress timeout."
1393 for pid in $cpids; do
1394 $PS -p $pid > /dev/null 2>&1
1395 if (($? == 0)); then
1396 log_must $KILL -USR1 $pid
1402 # Verify a given hotspare disk is inuse or avail
1404 # Return 0 is pool/disk matches expected state, 1 otherwise
1406 function check_hotspare_state # pool disk state{inuse,avail}
1409 typeset disk=${2#/dev/dsk/}
1412 cur_state=$(get_device_state $pool $disk "spares")
1414 if [[ $state != ${cur_state} ]]; then
1421 # Verify a given slog disk is inuse or avail
1423 # Return 0 is pool/disk matches expected state, 1 otherwise
1425 function check_slog_state # pool disk state{online,offline,unavail}
1428 typeset disk=${2#/dev/dsk/}
1431 cur_state=$(get_device_state $pool $disk "logs")
1433 if [[ $state != ${cur_state} ]]; then
1440 # Verify a given vdev disk is inuse or avail
1442 # Return 0 is pool/disk matches expected state, 1 otherwise
1444 function check_vdev_state # pool disk state{online,offline,unavail}
1447 typeset disk=${2#/dev/dsk/}
1450 cur_state=$(get_device_state $pool $disk)
1452 if [[ $state != ${cur_state} ]]; then
1459 # Check the output of 'zpool status -v <pool>',
1460 # and to see if the content of <token> contain the <keyword> specified.
1462 # Return 0 is contain, 1 otherwise
1464 function check_pool_status # pool token keyword
1470 $ZPOOL status -v "$pool" 2>/dev/null | $NAWK -v token="$token:" '
1471 ($1==token) {print $0}' \
1472 | $GREP -i "$keyword" > /dev/null 2>&1
1478 # These 5 following functions are instance of check_pool_status()
1479 # is_pool_resilvering - to check if the pool is resilver in progress
1480 # is_pool_resilvered - to check if the pool is resilver completed
1481 # is_pool_scrubbing - to check if the pool is scrub in progress
1482 # is_pool_scrubbed - to check if the pool is scrub completed
1483 # is_pool_scrub_stopped - to check if the pool is scrub stopped
1485 function is_pool_resilvering #pool
1487 check_pool_status "$1" "scan" "resilver in progress since "
1491 function is_pool_resilvered #pool
1493 check_pool_status "$1" "scan" "resilvered "
1497 function is_pool_scrubbing #pool
1499 check_pool_status "$1" "scan" "scrub in progress since "
1503 function is_pool_scrubbed #pool
1505 check_pool_status "$1" "scan" "scrub repaired"
1509 function is_pool_scrub_stopped #pool
1511 check_pool_status "$1" "scan" "scrub canceled"
1516 # Use create_pool()/destroy_pool() to clean up the infomation in
1517 # in the given disk to avoid slice overlapping.
1519 function cleanup_devices #vdevs
1521 typeset pool="foopool$$"
1523 if poolexists $pool ; then
1527 create_pool $pool $@
1534 # Verify the rsh connectivity to each remote host in RHOSTS.
1536 # Return 0 if remote host is accessible; otherwise 1.
1537 # $1 remote host name
1540 function verify_rsh_connect #rhost, username
1544 typeset rsh_cmd="$RSH -n"
1547 $GETENT hosts $rhost >/dev/null 2>&1
1548 if (($? != 0)); then
1549 log_note "$rhost cannot be found from" \
1550 "administrative database."
1554 $PING $rhost 3 >/dev/null 2>&1
1555 if (($? != 0)); then
1556 log_note "$rhost is not reachable."
1560 if ((${#username} != 0)); then
1561 rsh_cmd="$rsh_cmd -l $username"
1562 cur_user="given user \"$username\""
1564 cur_user="current user \"`$LOGNAME`\""
1567 if ! $rsh_cmd $rhost $TRUE; then
1568 log_note "$RSH to $rhost is not accessible" \
1577 # Verify the remote host connection via rsh after rebooting
1580 function verify_remote
1585 # The following loop waits for the remote system rebooting.
1586 # Each iteration will wait for 150 seconds. there are
1587 # total 5 iterations, so the total timeout value will
1588 # be 12.5 minutes for the system rebooting. This number
1589 # is an approxiate number.
1592 while ! verify_rsh_connect $rhost; do
1594 ((count = count + 1))
1595 if ((count > 5)); then
1603 # Replacement function for /usr/bin/rsh. This function will include
1604 # the /usr/bin/rsh and meanwhile return the execution status of the
1607 # $1 usrname passing down to -l option of /usr/bin/rsh
1608 # $2 remote machine hostname
1609 # $3... command string
1623 err_file=/tmp/${rhost}.$$.err
1624 if ((${#ruser} == 0)); then
1627 rsh_str="$RSH -n -l $ruser"
1630 $rsh_str $rhost /usr/bin/ksh -c "'$cmd_str; \
1631 print -u 2 \"status=\$?\"'" \
1632 >/dev/null 2>$err_file
1634 if (($ret != 0)); then
1636 $RM -f $std_file $err_file
1637 log_fail "$RSH itself failed with exit code $ret..."
1640 ret=$($GREP -v 'print -u 2' $err_file | $GREP 'status=' | \
1642 (($ret != 0)) && $CAT $err_file >&2
1644 $RM -f $err_file >/dev/null 2>&1
1649 # Get the SUNWstc-fs-zfs package installation path in a remote host
1650 # $1 remote host name
1652 function get_remote_pkgpath
1657 pkgpath=$($RSH -n $rhost "$PKGINFO -l SUNWstc-fs-zfs | $GREP BASEDIR: |\
1664 # A function to find and locate free disks on a system or from given
1665 # disks as the parameter. It works by locating disks that are in use
1666 # as swap devices and dump devices, and also disks listed in /etc/vfstab
1668 # $@ given disks to find which are free, default is all disks in
1671 # @return a string containing the list of available disks
1675 sfi=/tmp/swaplist.$$
1676 dmpi=/tmp/dumpdev.$$
1677 max_finddisksnum=${MAX_FINDDISKSNUM:-6}
1680 $DUMPADM > $dmpi 2>/dev/null
1682 # write an awk script that can process the output of format
1683 # to produce a list of disks we know about. Note that we have
1684 # to escape "$2" so that the shell doesn't interpret it while
1685 # we're creating the awk script.
1686 # -------------------
1687 $CAT > /tmp/find_disks.awk <<EOF
1696 if (searchdisks && \$2 !~ "^$"){
1702 /^AVAILABLE DISK SELECTIONS:/{
1706 #---------------------
1708 $CHMOD 755 /tmp/find_disks.awk
1709 disks=${@:-$($ECHO "" | $FORMAT -e 2>/dev/null | /tmp/find_disks.awk)}
1710 $RM /tmp/find_disks.awk
1713 for disk in $disks; do
1715 $GREP "${disk}[sp]" /etc/mnttab >/dev/null
1716 (($? == 0)) && continue
1718 $GREP "${disk}[sp]" $sfi >/dev/null
1719 (($? == 0)) && continue
1720 # check for dump device
1721 $GREP "${disk}[sp]" $dmpi >/dev/null
1722 (($? == 0)) && continue
1723 # check to see if this disk hasn't been explicitly excluded
1724 # by a user-set environment variable
1725 $ECHO "${ZFS_HOST_DEVICES_IGNORE}" | $GREP "${disk}" > /dev/null
1726 (($? == 0)) && continue
1727 unused_candidates="$unused_candidates $disk"
1732 # now just check to see if those disks do actually exist
1733 # by looking for a device pointing to the first slice in
1734 # each case. limit the number to max_finddisksnum
1736 for disk in $unused_candidates; do
1737 if [ -b /dev/dsk/${disk}s0 ]; then
1738 if [ $count -lt $max_finddisksnum ]; then
1739 unused="$unused $disk"
1740 # do not impose limit if $@ is provided
1741 [[ -z $@ ]] && ((count = count + 1))
1746 # finally, return our disk list
1751 # Add specified user to specified group
1755 # $3 base of the homedir (optional)
1757 function add_user #<group_name> <user_name> <basedir>
1761 typeset basedir=${3:-"/var/tmp"}
1763 if ((${#gname} == 0 || ${#uname} == 0)); then
1764 log_fail "group name or user name are not defined."
1767 log_must $USERADD -g $gname -d $basedir/$uname -m $uname
1773 # Delete the specified user.
1776 # $2 base of the homedir (optional)
1778 function del_user #<logname> <basedir>
1781 typeset basedir=${2:-"/var/tmp"}
1783 if ((${#user} == 0)); then
1784 log_fail "login name is necessary."
1787 if $ID $user > /dev/null 2>&1; then
1788 log_must $USERDEL $user
1791 [[ -d $basedir/$user ]] && $RM -fr $basedir/$user
1797 # Select valid gid and create specified group.
1801 function add_group #<group_name>
1805 if ((${#group} == 0)); then
1806 log_fail "group name is necessary."
1809 # Assign 100 as the base gid
1812 $GROUPADD -g $gid $group > /dev/null 2>&1
1816 # The gid is not unique
1824 # Delete the specified group.
1828 function del_group #<group_name>
1831 if ((${#grp} == 0)); then
1832 log_fail "group name is necessary."
1835 $GROUPMOD -n $grp $grp > /dev/null 2>&1
1838 # Group does not exist.
1840 # Name already exists as a group name
1841 9) log_must $GROUPDEL $grp ;;
1849 # This function will return true if it's safe to destroy the pool passed
1850 # as argument 1. It checks for pools based on zvols and files, and also
1851 # files contained in a pool that may have a different mountpoint.
1853 function safe_to_destroy_pool { # $1 the pool name
1856 typeset DONT_DESTROY=""
1858 # We check that by deleting the $1 pool, we're not
1859 # going to pull the rug out from other pools. Do this
1860 # by looking at all other pools, ensuring that they
1861 # aren't built from files or zvols contained in this pool.
1863 for pool in $($ZPOOL list -H -o name)
1867 # this is a list of the top-level directories in each of the
1868 # files that make up the path to the files the pool is based on
1869 FILEPOOL=$($ZPOOL status -v $pool | $GREP /$1/ | \
1872 # this is a list of the zvols that make up the pool
1873 ZVOLPOOL=$($ZPOOL status -v $pool | $GREP "/dev/zvol/dsk/$1$" \
1874 | $AWK '{print $1}')
1876 # also want to determine if it's a file-based pool using an
1877 # alternate mountpoint...
1878 POOL_FILE_DIRS=$($ZPOOL status -v $pool | \
1879 $GREP / | $AWK '{print $1}' | \
1880 $AWK -F/ '{print $2}' | $GREP -v "dev")
1882 for pooldir in $POOL_FILE_DIRS
1884 OUTPUT=$($ZFS list -H -r -o mountpoint $1 | \
1885 $GREP "${pooldir}$" | $AWK '{print $1}')
1887 ALTMOUNTPOOL="${ALTMOUNTPOOL}${OUTPUT}"
1891 if [ ! -z "$ZVOLPOOL" ]
1894 log_note "Pool $pool is built from $ZVOLPOOL on $1"
1897 if [ ! -z "$FILEPOOL" ]
1900 log_note "Pool $pool is built from $FILEPOOL on $1"
1903 if [ ! -z "$ALTMOUNTPOOL" ]
1906 log_note "Pool $pool is built from $ALTMOUNTPOOL on $1"
1910 if [ -z "${DONT_DESTROY}" ]
1914 log_note "Warning: it is not safe to destroy $1!"
1920 # Get IP address of hostname
1923 function getipbyhost
1926 ip=`$ARP $1 2>/dev/null | $AWK -F\) '{print $1}' \
1927 | $AWK -F\('{print $2}'`
1932 # Setup iSCSI initiator to target
1933 # $1 target hostname
1935 function iscsi_isetup
1937 # check svc:/network/iscsi_initiator:default state, try to enable it
1938 # if the state is not ON
1939 typeset ISCSII_FMRI="svc:/network/iscsi_initiator:default"
1940 if [[ "ON" != $($SVCS -H -o sta $ISCSII_FMRI) ]]; then
1941 log_must $SVCADM enable $ISCSII_FMRI
1944 while [[ "ON" != $($SVCS -H -o sta $ISCSII_FMRI) && \
1947 ((retry = retry - 1))
1951 if [[ "ON" != $($SVCS -H -o sta $ISCSII_FMRI) ]]; then
1952 log_fail "$ISCSII_FMRI service can not be enabled!"
1956 log_must $ISCSIADM add discovery-address $(getipbyhost $1)
1957 log_must $ISCSIADM modify discovery --sendtargets enable
1958 log_must $DEVFSADM -i iscsi
1962 # Check whether iscsi parameter is set as remote
1964 # return 0 if iscsi is set as remote, otherwise 1
1966 function check_iscsi_remote
1968 if [[ $iscsi == "remote" ]] ; then
1976 # Check if a volume is a valide iscsi target
1978 # return 0 if suceeds, otherwise, return 1
1980 function is_iscsi_target
1983 typeset target targets
1985 [[ -z $dataset ]] && return 1
1987 targets=$($ISCSITADM list target | $GREP "Target:" | $AWK '{print $2}')
1988 [[ -z $targets ]] && return 1
1990 for target in $targets; do
1991 [[ $dataset == $target ]] && return 0
1998 # Get the iSCSI name of a target
2006 [[ -z $target ]] && log_fail "No parameter."
2008 if ! is_iscsi_target $target ; then
2009 log_fail "Not a target."
2012 name=$($ISCSITADM list target $target | $GREP "iSCSI Name:" \
2013 | $AWK '{print $2}')
2019 # check svc:/system/iscsitgt:default state, try to enable it if the state
2022 function iscsitgt_setup
2024 log_must $RM -f $ISCSITGTFILE
2025 if [[ "ON" == $($SVCS -H -o sta $ISCSITGT_FMRI) ]]; then
2026 log_note "iscsitgt is already enabled"
2030 log_must $SVCADM enable -t $ISCSITGT_FMRI
2033 while [[ "ON" != $($SVCS -H -o sta $ISCSITGT_FMRI) && \
2037 ((retry = retry - 1))
2040 if [[ "ON" != $($SVCS -H -o sta $ISCSITGT_FMRI) ]]; then
2041 log_fail "$ISCSITGT_FMRI service can not be enabled!"
2044 log_must $TOUCH $ISCSITGTFILE
2048 # set DISABLED state of svc:/system/iscsitgt:default
2049 # which is the most suiteable state if $ISCSITGTFILE exists
2051 function iscsitgt_cleanup
2053 if [[ -e $ISCSITGTFILE ]]; then
2054 log_must $SVCADM disable $ISCSITGT_FMRI
2055 log_must $RM -f $ISCSITGTFILE
2060 # Close iSCSI initiator to target
2061 # $1 target hostname
2063 function iscsi_iclose
2065 log_must $ISCSIADM modify discovery --sendtargets disable
2066 log_must $ISCSIADM remove discovery-address $(getipbyhost $1)
2071 # Get the available ZFS compression options
2072 # $1 option type zfs_set|zfs_compress
2074 function get_compress_opts
2076 typeset COMPRESS_OPTS
2077 typeset GZIP_OPTS="gzip gzip-1 gzip-2 gzip-3 gzip-4 gzip-5 \
2078 gzip-6 gzip-7 gzip-8 gzip-9"
2080 if [[ $1 == "zfs_compress" ]] ; then
2081 COMPRESS_OPTS="on lzjb"
2082 elif [[ $1 == "zfs_set" ]] ; then
2083 COMPRESS_OPTS="on off lzjb"
2085 typeset valid_opts="$COMPRESS_OPTS"
2086 $ZFS get 2>&1 | $GREP gzip >/dev/null 2>&1
2087 if [[ $? -eq 0 ]]; then
2088 valid_opts="$valid_opts $GZIP_OPTS"
2094 # Verify zfs operation with -p option work as expected
2095 # $1 operation, value could be create, clone or rename
2096 # $2 dataset type, value could be fs or vol
2098 # $4 new dataset name
2100 function verify_opt_p_ops
2105 typeset newdataset=$4
2107 if [[ $datatype != "fs" && $datatype != "vol" ]]; then
2108 log_fail "$datatype is not supported."
2111 # check parameters accordingly
2116 if [[ $datatype == "vol" ]]; then
2117 ops="create -V $VOLSIZE"
2121 if [[ -z $newdataset ]]; then
2122 log_fail "newdataset should not be empty" \
2125 log_must datasetexists $dataset
2126 log_must snapexists $dataset
2129 if [[ -z $newdataset ]]; then
2130 log_fail "newdataset should not be empty" \
2133 log_must datasetexists $dataset
2134 log_mustnot snapexists $dataset
2137 log_fail "$ops is not supported."
2141 # make sure the upper level filesystem does not exist
2142 if datasetexists ${newdataset%/*} ; then
2143 log_must $ZFS destroy -rRf ${newdataset%/*}
2146 # without -p option, operation will fail
2147 log_mustnot $ZFS $ops $dataset $newdataset
2148 log_mustnot datasetexists $newdataset ${newdataset%/*}
2150 # with -p option, operation should succeed
2151 log_must $ZFS $ops -p $dataset $newdataset
2152 if ! datasetexists $newdataset ; then
2153 log_fail "-p option does not work for $ops"
2156 # when $ops is create or clone, redo the operation still return zero
2157 if [[ $ops != "rename" ]]; then
2158 log_must $ZFS $ops -p $dataset $newdataset
2165 # Get configuration of pool
2175 if ! poolexists "$pool" ; then
2178 alt_root=$($ZPOOL list -H $pool | $AWK '{print $NF}')
2179 if [[ $alt_root == "-" ]]; then
2180 value=$($ZDB -C $pool | $GREP "$config:" | $AWK -F: \
2183 value=$($ZDB -e $pool | $GREP "$config:" | $AWK -F: \
2186 if [[ -n $value ]] ; then
2196 # Privated function. Random select one of items from arguments.
2201 function _random_get
2208 ((ind = RANDOM % cnt + 1))
2210 typeset ret=$($ECHO "$str" | $CUT -f $ind -d ' ')
2215 # Random select one of item from arguments which include NONE string
2217 function random_get_with_non
2222 _random_get "$cnt" "$@"
2226 # Random select one of item from arguments which doesn't include NONE string
2230 _random_get "$#" "$@"
2234 # Detect if the current system support slog
2236 function verify_slog_support
2238 typeset dir=/tmp/disk.$$
2244 $MKFILE 64M $vdev $sdev
2247 if ! $ZPOOL create -n $pool $vdev log $sdev > /dev/null 2>&1; then
2256 # The function will generate a dataset name with specific length
2257 # $1, the length of the name
2258 # $2, the base string to construct the name
2260 function gen_dataset_name
2263 typeset basestr="$2"
2264 typeset -i baselen=${#basestr}
2268 if ((len % baselen == 0)); then
2269 ((iter = len / baselen))
2271 ((iter = len / baselen + 1))
2273 while ((iter > 0)); do
2274 l_name="${l_name}$basestr"
2283 # Get cksum tuple of dataset
2286 # sample zdb output:
2287 # Dataset data/test [ZPL], ID 355, cr_txg 2413856, 31.0K, 7 objects, rootbp
2288 # DVA[0]=<0:803046400:200> DVA[1]=<0:81199000:200> [L0 DMU objset] fletcher4
2289 # lzjb LE contiguous unique double size=800L/200P birth=2413856L/2413856P
2290 # fill=7 cksum=11ce125712:643a9c18ee2:125e25238fca0:254a3f74b59744
2291 function datasetcksum
2295 cksum=$($ZDB -vvv $1 | $GREP "^Dataset $1 \[" | $GREP "cksum" \
2296 | $AWK -F= '{print $7}')
2307 cksum=$($CKSUM $1 | $AWK '{print $1}')
2312 # Get the given disk/slice state from the specific field of the pool
2314 function get_device_state #pool disk field("", "spares","logs")
2317 typeset disk=${2#/dev/dsk/}
2318 typeset field=${3:-$pool}
2320 state=$($ZPOOL status -v "$pool" 2>/dev/null | \
2321 $NAWK -v device=$disk -v pool=$pool -v field=$field \
2322 'BEGIN {startconfig=0; startfield=0; }
2323 /config:/ {startconfig=1}
2324 (startconfig==1) && ($1==field) {startfield=1; next;}
2325 (startfield==1) && ($1==device) {print $2; exit;}
2327 ($1==field || $1 ~ "^spares$" || $1 ~ "^logs$") {startfield=0}')
2333 # print the given directory filesystem type
2341 if [[ -z $dir ]]; then
2342 log_fail "Usage: get_fstype <directory>"
2349 $DF -n $dir | $AWK '{print $3}'
2353 # Given a disk, label it to VTOC regardless what label was on the disk
2359 if [[ -z $disk ]]; then
2360 log_fail "The disk name is unspecified."
2362 typeset label_file=/var/tmp/labelvtoc.$$
2363 typeset arch=$($UNAME -p)
2365 if [[ $arch == "i386" ]]; then
2366 $ECHO "label" > $label_file
2367 $ECHO "0" >> $label_file
2368 $ECHO "" >> $label_file
2369 $ECHO "q" >> $label_file
2370 $ECHO "q" >> $label_file
2372 $FDISK -B $disk >/dev/null 2>&1
2373 # wait a while for fdisk finishes
2375 elif [[ $arch == "sparc" ]]; then
2376 $ECHO "label" > $label_file
2377 $ECHO "0" >> $label_file
2378 $ECHO "" >> $label_file
2379 $ECHO "" >> $label_file
2380 $ECHO "" >> $label_file
2381 $ECHO "q" >> $label_file
2383 log_fail "unknown arch type"
2386 $FORMAT -e -s -d $disk -f $label_file
2387 typeset -i ret_val=$?
2390 # wait the format to finish
2393 if ((ret_val != 0)); then
2394 log_fail "unable to label $disk as VTOC."
2401 # check if the system was installed as zfsroot or not
2402 # return: 0 ture, otherwise false
2406 $DF -n / | $GREP zfs > /dev/null 2>&1
2411 # get the root filesystem name if it's zfsroot system.
2413 # return: root filesystem name
2417 rootfs=$($AWK '{if ($2 == "/" && $3 == "zfs") print $1}' \
2419 if [[ -z "$rootfs" ]]; then
2420 log_fail "Can not get rootfs"
2422 $ZFS list $rootfs > /dev/null 2>&1
2423 if (($? == 0)); then
2426 log_fail "This is not a zfsroot system."
2431 # get the rootfs's pool name
2435 function get_rootpool
2439 rootfs=$($AWK '{if ($2 == "/" && $3 =="zfs") print $1}' \
2441 if [[ -z "$rootfs" ]]; then
2442 log_fail "Can not get rootpool"
2444 $ZFS list $rootfs > /dev/null 2>&1
2445 if (($? == 0)); then
2446 rootpool=`$ECHO $rootfs | awk -F\/ '{print $1}'`
2449 log_fail "This is not a zfsroot system."
2454 # Get the sub string from specified source string
2457 # $2 start position. Count from 1
2460 function get_substr #src_str pos offset
2465 $NAWK -v pos=$2 -v offset=$3 '{print substr($0, pos, offset)}'
2469 # Check if the given device is physical device
2471 function is_physical_device #device
2473 typeset device=${1#/dev/dsk/}
2474 device=${device#/dev/rdsk/}
2476 $ECHO $device | $EGREP "^c[0-F]+([td][0-F]+)+$" > /dev/null 2>&1
2481 # Get the directory path of given device
2483 function get_device_dir #device
2487 if ! $(is_physical_device $device) ; then
2488 if [[ $device != "/" ]]; then
2498 # Get the package name
2500 function get_package_name
2502 typeset dirpath=${1:-$STC_NAME}
2504 echo "SUNWstc-${dirpath}" | /usr/bin/sed -e "s/\//-/g"
2508 # Get the word numbers from a string separated by white space
2510 function get_word_count
2516 # To verify if the require numbers of disks is given
2518 function verify_disk_count
2520 typeset -i min=${2:-1}
2522 typeset -i count=$(get_word_count "$1")
2524 if ((count < min)); then
2525 log_untested "A minimum of $min disks is required to run." \
2526 " You specified $count disk(s)"
2530 function ds_is_volume
2532 typeset type=$(get_prop type $1)
2533 [[ $type = "volume" ]] && return 0
2537 function ds_is_filesystem
2539 typeset type=$(get_prop type $1)
2540 [[ $type = "filesystem" ]] && return 0
2544 function ds_is_snapshot
2546 typeset type=$(get_prop type $1)
2547 [[ $type = "snapshot" ]] && return 0
2552 # Check if Trusted Extensions are installed and enabled
2554 function is_te_enabled
2556 $SVCS -H -o state labeld 2>/dev/null | $GREP "enabled"
2557 if (($? != 0)); then
2564 # Utility function to determine if a system has multiple cpus.
2567 (($($PSRINFO | $WC -l) > 1))
2570 function get_cpu_freq
2572 $PSRINFO -v 0 | $AWK '/processor operates at/ {print $6}'
2575 # Run the given command as the user provided.
2581 eval \$SU \$user -c \"$@\" > /tmp/out 2>/tmp/err
2586 # Check if the pool contains the specified vdevs
2591 # Return 0 if the vdevs are contained in the pool, 1 if any of the specified
2592 # vdevs is not in the pool, and 2 if pool name is missing.
2594 function vdevs_in_pool
2599 if [[ -z $pool ]]; then
2600 log_note "Missing pool name."
2606 typeset tmpfile=$($MKTEMP)
2607 $ZPOOL list -Hv "$pool" >$tmpfile
2609 $GREP -w ${vdev##*/} $tmpfile >/dev/null 2>&1
2610 [[ $? -ne 0 ]] && return 1