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.
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.
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]
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.
32 .
${STF_TOOLS}/include
/logapi.shlib
33 .
${STF_SUITE}/include
/math.shlib
36 # Apply constrained path when available. This is required since the
37 # PATH may have been modified by sudo's secure_path behavior.
39 if [ -n "$STF_PATH" ]; then
43 # Linux kernel version comparison function
45 # $1 Linux version ("4.10", "2.6.32") or blank for installed Linux version
47 # Used for comparison: if [ $(linux_version) -ge $(linux_version "2.6.32") ]
49 function linux_version
53 [[ -z "$ver" ]] && ver
=$
(uname
-r |
grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+")
55 typeset version
=$
(echo $ver | cut
-d '.' -f 1)
56 typeset major
=$
(echo $ver | cut
-d '.' -f 2)
57 typeset minor
=$
(echo $ver | cut
-d '.' -f 3)
59 [[ -z "$version" ]] && version
=0
60 [[ -z "$major" ]] && major
=0
61 [[ -z "$minor" ]] && minor
=0
63 echo $
((version
* 10000 + major
* 100 + minor
))
66 # Determine if this is a Linux test system
68 # Return 0 if platform Linux, 1 if otherwise
72 if [[ $
(uname
-o) == "GNU/Linux" ]]; then
79 # Determine if this is a 32-bit system
81 # Return 0 if platform is 32-bit, 1 if otherwise
85 if [[ $
(getconf LONG_BIT
) == "32" ]]; then
92 # Determine if kmemleak is enabled
94 # Return 0 if kmemleak is enabled, 1 if otherwise
98 if is_linux
&& [[ -e /sys
/kernel
/debug
/kmemleak
]]; then
105 # Determine whether a dataset is mounted
108 # $2 filesystem type; optional - defaulted to zfs
110 # Return 0 if dataset is mounted; 1 if unmounted; 2 on error
115 [[ -z $fstype ]] && fstype
=zfs
116 typeset out dir name ret
120 if [[ "$1" == "/"* ]] ; then
121 for out
in $
(zfs mount |
awk '{print $2}'); do
122 [[ $1 == $out ]] && return 0
125 for out
in $
(zfs mount |
awk '{print $1}'); do
126 [[ $1 == $out ]] && return 0
131 out
=$
(df
-F $fstype $1 2>/dev
/null
)
133 (($ret != 0)) && return $ret
141 [[ "$1" == "$dir" ||
"$1" == "$name" ]] && return 0
144 out
=$
(df
-t $fstype $1 2>/dev
/null
)
148 if [[ -L "$ZVOL_DEVDIR/$1" ]]; then
149 link
=$
(readlink
-f $ZVOL_DEVDIR/$1)
150 [[ -n "$link" ]] && \
151 mount |
grep -q "^$link" && \
160 # Return 0 if a dataset is mounted; 1 otherwise
163 # $2 filesystem type; optional - defaulted to zfs
168 (($?
== 0)) && return 0
172 # Return 0 if a dataset is unmounted; 1 otherwise
175 # $2 filesystem type; optional - defaulted to zfs
180 (($?
== 1)) && return 0
190 echo $1 |
sed "s/,/ /g"
193 function default_setup
195 default_setup_noexit
"$@"
201 # Given a list of disks, setup storage pools and datasets.
203 function default_setup_noexit
208 log_note begin default_setup_noexit
210 if is_global_zone
; then
211 if poolexists
$TESTPOOL ; then
212 destroy_pool
$TESTPOOL
214 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
215 log_must zpool create
-f $TESTPOOL $disklist
220 rm -rf $TESTDIR || log_unresolved Could not remove
$TESTDIR
221 mkdir
-p $TESTDIR || log_unresolved Could not create
$TESTDIR
223 log_must zfs create
$TESTPOOL/$TESTFS
224 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
226 if [[ -n $container ]]; then
227 rm -rf $TESTDIR1 || \
228 log_unresolved Could not remove
$TESTDIR1
229 mkdir
-p $TESTDIR1 || \
230 log_unresolved Could not create
$TESTDIR1
232 log_must zfs create
$TESTPOOL/$TESTCTR
233 log_must zfs
set canmount
=off
$TESTPOOL/$TESTCTR
234 log_must zfs create
$TESTPOOL/$TESTCTR/$TESTFS1
235 log_must zfs
set mountpoint
=$TESTDIR1 \
236 $TESTPOOL/$TESTCTR/$TESTFS1
239 if [[ -n $volume ]]; then
240 if is_global_zone
; then
241 log_must zfs create
-V $VOLSIZE $TESTPOOL/$TESTVOL
244 log_must zfs create
$TESTPOOL/$TESTVOL
250 # Given a list of disks, setup a storage pool, file system and
253 function default_container_setup
257 default_setup
"$disklist" "true"
261 # Given a list of disks, setup a storage pool,file system
264 function default_volume_setup
268 default_setup
"$disklist" "" "true"
272 # Given a list of disks, setup a storage pool,file system,
273 # a container and a volume.
275 function default_container_volume_setup
279 default_setup
"$disklist" "true" "true"
283 # Create a snapshot on a filesystem or volume. Defaultly create a snapshot on
286 # $1 Existing filesystem or volume name. Default, $TESTFS
287 # $2 snapshot name. Default, $TESTSNAP
289 function create_snapshot
291 typeset fs_vol
=${1:-$TESTFS}
292 typeset snap
=${2:-$TESTSNAP}
294 [[ -z $fs_vol ]] && log_fail
"Filesystem or volume's name is undefined."
295 [[ -z $snap ]] && log_fail
"Snapshot's name is undefined."
297 if snapexists
$fs_vol@
$snap; then
298 log_fail
"$fs_vol@$snap already exists."
300 datasetexists
$fs_vol || \
301 log_fail
"$fs_vol must exist."
303 log_must zfs snapshot
$fs_vol@
$snap
307 # Create a clone from a snapshot, default clone name is $TESTCLONE.
309 # $1 Existing snapshot, $TESTPOOL/$TESTFS@$TESTSNAP is default.
310 # $2 Clone name, $TESTPOOL/$TESTCLONE is default.
312 function create_clone
# snapshot clone
314 typeset snap
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
315 typeset clone
=${2:-$TESTPOOL/$TESTCLONE}
318 log_fail
"Snapshot name is undefined."
320 log_fail
"Clone name is undefined."
322 log_must zfs clone
$snap $clone
326 # Create a bookmark of the given snapshot. Defaultly create a bookmark on
329 # $1 Existing filesystem or volume name. Default, $TESTFS
330 # $2 Existing snapshot name. Default, $TESTSNAP
331 # $3 bookmark name. Default, $TESTBKMARK
333 function create_bookmark
335 typeset fs_vol
=${1:-$TESTFS}
336 typeset snap
=${2:-$TESTSNAP}
337 typeset bkmark
=${3:-$TESTBKMARK}
339 [[ -z $fs_vol ]] && log_fail
"Filesystem or volume's name is undefined."
340 [[ -z $snap ]] && log_fail
"Snapshot's name is undefined."
341 [[ -z $bkmark ]] && log_fail
"Bookmark's name is undefined."
343 if bkmarkexists
$fs_vol#$bkmark; then
344 log_fail
"$fs_vol#$bkmark already exists."
346 datasetexists
$fs_vol || \
347 log_fail
"$fs_vol must exist."
348 snapexists
$fs_vol@
$snap || \
349 log_fail
"$fs_vol@$snap must exist."
351 log_must zfs bookmark
$fs_vol@
$snap $fs_vol#$bkmark
354 function default_mirror_setup
356 default_mirror_setup_noexit
$1 $2 $3
362 # Given a pair of disks, set up a storage pool and dataset for the mirror
363 # @parameters: $1 the primary side of the mirror
364 # $2 the secondary side of the mirror
365 # @uses: ZPOOL ZFS TESTPOOL TESTFS
366 function default_mirror_setup_noexit
368 readonly func
="default_mirror_setup_noexit"
372 [[ -z $primary ]] && \
373 log_fail
"$func: No parameters passed"
374 [[ -z $secondary ]] && \
375 log_fail
"$func: No secondary partition passed"
376 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
377 log_must zpool create
-f $TESTPOOL mirror $@
378 log_must zfs create
$TESTPOOL/$TESTFS
379 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
383 # create a number of mirrors.
384 # We create a number($1) of 2 way mirrors using the pairs of disks named
385 # on the command line. These mirrors are *not* mounted
386 # @parameters: $1 the number of mirrors to create
387 # $... the devices to use to create the mirrors on
388 # @uses: ZPOOL ZFS TESTPOOL
389 function setup_mirrors
391 typeset
-i nmirrors
=$1
394 while ((nmirrors
> 0)); do
395 log_must
test -n "$1" -a -n "$2"
396 [[ -d /$TESTPOOL$nmirrors ]] && rm -rf /$TESTPOOL$nmirrors
397 log_must zpool create
-f $TESTPOOL$nmirrors mirror
$1 $2
399 ((nmirrors
= nmirrors
- 1))
404 # create a number of raidz pools.
405 # We create a number($1) of 2 raidz pools using the pairs of disks named
406 # on the command line. These pools are *not* mounted
407 # @parameters: $1 the number of pools to create
408 # $... the devices to use to create the pools on
409 # @uses: ZPOOL ZFS TESTPOOL
410 function setup_raidzs
412 typeset
-i nraidzs
=$1
415 while ((nraidzs
> 0)); do
416 log_must
test -n "$1" -a -n "$2"
417 [[ -d /$TESTPOOL$nraidzs ]] && rm -rf /$TESTPOOL$nraidzs
418 log_must zpool create
-f $TESTPOOL$nraidzs raidz
$1 $2
420 ((nraidzs
= nraidzs
- 1))
425 # Destroy the configured testpool mirrors.
426 # the mirrors are of the form ${TESTPOOL}{number}
427 # @uses: ZPOOL ZFS TESTPOOL
428 function destroy_mirrors
430 default_cleanup_noexit
436 # Given a minimum of two disks, set up a storage pool and dataset for the raid-z
437 # $1 the list of disks
439 function default_raidz_setup
441 typeset disklist
="$*"
442 disks
=(${disklist[*]})
444 if [[ ${#disks[*]} -lt 2 ]]; then
445 log_fail
"A raid-z requires a minimum of two disks."
448 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
449 log_must zpool create
-f $TESTPOOL raidz
$1 $2 $3
450 log_must zfs create
$TESTPOOL/$TESTFS
451 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
457 # Common function used to cleanup storage pools and datasets.
459 # Invoked at the start of the test suite to ensure the system
460 # is in a known state, and also at the end of each set of
461 # sub-tests to ensure errors from one set of tests doesn't
462 # impact the execution of the next set.
464 function default_cleanup
466 default_cleanup_noexit
471 function default_cleanup_noexit
476 # Destroying the pool will also destroy any
477 # filesystems it contains.
479 if is_global_zone
; then
480 zfs unmount
-a > /dev
/null
2>&1
481 exclude
=`eval echo \"'(${KEEP})'\"`
482 ALL_POOLS
=$
(zpool list
-H -o name \
483 |
grep -v "$NO_POOLS" |
egrep -v "$exclude")
484 # Here, we loop through the pools we're allowed to
485 # destroy, only destroying them if it's safe to do
487 while [ ! -z ${ALL_POOLS} ]
489 for pool
in ${ALL_POOLS}
491 if safe_to_destroy_pool
$pool ;
495 ALL_POOLS
=$
(zpool list
-H -o name \
496 |
grep -v "$NO_POOLS" \
497 |
egrep -v "$exclude")
504 for fs
in $
(zfs list
-H -o name \
505 |
grep "^$ZONE_POOL/$ZONE_CTR[01234]/"); do
506 datasetexists
$fs && \
507 log_must zfs destroy
-Rf $fs
510 # Need cleanup here to avoid garbage dir left.
511 for fs
in $
(zfs list
-H -o name
); do
512 [[ $fs == /$ZONE_POOL ]] && continue
513 [[ -d $fs ]] && log_must
rm -rf $fs/*
517 # Reset the $ZONE_POOL/$ZONE_CTR[01234] file systems property to
520 for fs
in $
(zfs list
-H -o name
); do
521 if [[ $fs == $ZONE_POOL/$ZONE_CTR[01234] ]]; then
522 log_must zfs
set reservation
=none
$fs
523 log_must zfs
set recordsize
=128K
$fs
524 log_must zfs
set mountpoint
=/$fs $fs
526 enc
=$
(get_prop encryption
$fs)
527 if [[ $?
-ne 0 ]] ||
[[ -z "$enc" ]] || \
528 [[ "$enc" == "off" ]]; then
529 log_must zfs
set checksum
=on
$fs
531 log_must zfs
set compression
=off
$fs
532 log_must zfs
set atime
=on
$fs
533 log_must zfs
set devices
=off
$fs
534 log_must zfs
set exec=on
$fs
535 log_must zfs
set setuid
=on
$fs
536 log_must zfs
set readonly=off
$fs
537 log_must zfs
set snapdir
=hidden
$fs
538 log_must zfs
set aclmode
=groupmask
$fs
539 log_must zfs
set aclinherit
=secure
$fs
544 [[ -d $TESTDIR ]] && \
545 log_must
rm -rf $TESTDIR
548 if is_mpath_device
$disk1; then
555 # Common function used to cleanup storage pools, file systems
558 function default_container_cleanup
560 if ! is_global_zone
; then
564 ismounted
$TESTPOOL/$TESTCTR/$TESTFS1
566 log_must zfs unmount
$TESTPOOL/$TESTCTR/$TESTFS1
568 datasetexists
$TESTPOOL/$TESTCTR/$TESTFS1 && \
569 log_must zfs destroy
-R $TESTPOOL/$TESTCTR/$TESTFS1
571 datasetexists
$TESTPOOL/$TESTCTR && \
572 log_must zfs destroy
-Rf $TESTPOOL/$TESTCTR
574 [[ -e $TESTDIR1 ]] && \
575 log_must
rm -rf $TESTDIR1 > /dev
/null
2>&1
581 # Common function used to cleanup snapshot of file system or volume. Default to
582 # delete the file system's snapshot
586 function destroy_snapshot
588 typeset snap
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
590 if ! snapexists
$snap; then
591 log_fail
"'$snap' does not existed."
595 # For the sake of the value which come from 'get_prop' is not equal
596 # to the really mountpoint when the snapshot is unmounted. So, firstly
597 # check and make sure this snapshot's been mounted in current system.
600 if ismounted
$snap; then
601 mtpt
=$
(get_prop mountpoint
$snap)
603 log_fail
"get_prop mountpoint $snap failed."
606 log_must zfs destroy
$snap
607 [[ $mtpt != "" && -d $mtpt ]] && \
608 log_must
rm -rf $mtpt
612 # Common function used to cleanup clone.
616 function destroy_clone
618 typeset clone
=${1:-$TESTPOOL/$TESTCLONE}
620 if ! datasetexists
$clone; then
621 log_fail
"'$clone' does not existed."
624 # With the same reason in destroy_snapshot
626 if ismounted
$clone; then
627 mtpt
=$
(get_prop mountpoint
$clone)
629 log_fail
"get_prop mountpoint $clone failed."
632 log_must zfs destroy
$clone
633 [[ $mtpt != "" && -d $mtpt ]] && \
634 log_must
rm -rf $mtpt
638 # Common function used to cleanup bookmark of file system or volume. Default
639 # to delete the file system's bookmark.
643 function destroy_bookmark
645 typeset bkmark
=${1:-$TESTPOOL/$TESTFS#$TESTBKMARK}
647 if ! bkmarkexists
$bkmark; then
648 log_fail
"'$bkmarkp' does not existed."
651 log_must zfs destroy
$bkmark
654 # Return 0 if a snapshot exists; $? otherwise
660 zfs list
-H -t snapshot
"$1" > /dev
/null
2>&1
665 # Return 0 if a bookmark exists; $? otherwise
669 function bkmarkexists
671 zfs list
-H -t bookmark
"$1" > /dev
/null
2>&1
676 # Set a property to a certain value on a dataset.
677 # Sets a property of the dataset to the value as passed in.
679 # $1 dataset who's property is being set
681 # $3 value to set property to
683 # 0 if the property could be set.
684 # non-zero otherwise.
687 function dataset_setprop
689 typeset fn
=dataset_setprop
692 log_note
"$fn: Insufficient parameters (need 3, had $#)"
696 output
=$
(zfs
set $2=$3 $1 2>&1)
699 log_note
"Setting property on $1 failed."
700 log_note
"property $2=$3"
701 log_note
"Return Code: $rv"
702 log_note
"Output: $output"
709 # Assign suite defined dataset properties.
710 # This function is used to apply the suite's defined default set of
711 # properties to a dataset.
712 # @parameters: $1 dataset to use
713 # @uses: ZFS COMPRESSION_PROP CHECKSUM_PROP
715 # 0 if the dataset has been altered.
716 # 1 if no pool name was passed in.
717 # 2 if the dataset could not be found.
718 # 3 if the dataset could not have it's properties set.
720 function dataset_set_defaultproperties
724 [[ -z $dataset ]] && return 1
728 for confset
in $
(zfs list
); do
729 if [[ $dataset = $confset ]]; then
734 [[ $found -eq 0 ]] && return 2
735 if [[ -n $COMPRESSION_PROP ]]; then
736 dataset_setprop
$dataset compression
$COMPRESSION_PROP || \
738 log_note
"Compression set to '$COMPRESSION_PROP' on $dataset"
740 if [[ -n $CHECKSUM_PROP ]]; then
741 dataset_setprop
$dataset checksum
$CHECKSUM_PROP || \
743 log_note
"Checksum set to '$CHECKSUM_PROP' on $dataset"
749 # Check a numeric assertion
750 # @parameter: $@ the assertion to check
751 # @output: big loud notice if assertion failed
756 (($@
)) || log_fail
"$@"
760 # Function to format partition size of a disk
761 # Given a disk cxtxdx reduces all partitions
764 function zero_partitions
#<whole_disk_name>
770 DSK
=$DEV_DSKDIR/$diskname
771 DSK
=$
(echo $DSK |
sed -e "s|//|/|g")
772 log_must parted
$DSK -s -- mklabel gpt
773 blockdev
--rereadpt $DSK 2>/dev
/null
776 for i
in 0 1 3 4 5 6 7
778 log_must set_partition
$i "" 0mb
$diskname
786 # Given a slice, size and disk, this function
787 # formats the slice to the specified size.
788 # Size should be specified with units as per
789 # the `format` command requirements eg. 100mb 3gb
791 # NOTE: This entire interface is problematic for the Linux parted utilty
792 # which requires the end of the partition to be specified. It would be
793 # best to retire this interface and replace it with something more flexible.
794 # At the moment a best effort is made.
796 function set_partition
#<slice_num> <slice_start> <size_plus_units> <whole_disk_name>
798 typeset
-i slicenum
=$1
804 if [[ -z $size ||
-z $disk ]]; then
805 log_fail
"The size or disk name is unspecified."
807 typeset size_mb
=${size%%[mMgG]}
809 size_mb
=${size_mb%%[mMgG][bB]}
810 if [[ ${size:1:1} == 'g' ]]; then
811 ((size_mb
= size_mb
* 1024))
814 # Create GPT partition table when setting slice 0 or
815 # when the device doesn't already contain a GPT label.
816 parted
$DEV_DSKDIR/$disk -s -- print
1 >/dev
/null
818 if [[ $slicenum -eq 0 ||
$ret_val -ne 0 ]]; then
819 parted
$DEV_DSKDIR/$disk -s -- mklabel gpt
820 if [[ $?
-ne 0 ]]; then
821 log_note
"Failed to create GPT partition table on $disk"
826 # When no start is given align on the first cylinder.
827 if [[ -z "$start" ]]; then
831 # Determine the cylinder size for the device and using
832 # that calculate the end offset in cylinders.
833 typeset
-i cly_size_kb
=0
834 cly_size_kb
=$
(parted
-m $DEV_DSKDIR/$disk -s -- \
835 unit cyl print |
head -3 |
tail -1 | \
836 awk -F '[:k.]' '{print $4}')
837 ((end
= (size_mb
* 1024 / cly_size_kb
) + start
))
839 parted
$DEV_DSKDIR/$disk -s -- \
840 mkpart part
$slicenum ${start}cyl
${end}cyl
841 if [[ $?
-ne 0 ]]; then
842 log_note
"Failed to create partition $slicenum on $disk"
846 blockdev
--rereadpt $DEV_DSKDIR/$disk 2>/dev
/null
849 if [[ -z $slicenum ||
-z $size ||
-z $disk ]]; then
850 log_fail
"The slice, size or disk name is unspecified."
853 typeset format_file
=/var
/tmp
/format_in.$$
855 echo "partition" >$format_file
856 echo "$slicenum" >> $format_file
857 echo "" >> $format_file
858 echo "" >> $format_file
859 echo "$start" >> $format_file
860 echo "$size" >> $format_file
861 echo "label" >> $format_file
862 echo "" >> $format_file
863 echo "q" >> $format_file
864 echo "q" >> $format_file
866 format
-e -s -d $disk -f $format_file
871 if [[ $ret_val -ne 0 ]]; then
872 log_note
"Unable to format $disk slice $slicenum to $size"
879 # Delete all partitions on all disks - this is specifically for the use of multipath
880 # devices which currently can only be used in the test suite as raw/un-partitioned
881 # devices (ie a zpool cannot be created on a whole mpath device that has partitions)
883 function delete_partitions
887 if [[ -z $DISK_ARRAY_NUM ]]; then
888 DISK_ARRAY_NUM
=$
(echo ${DISKS} | nawk
'{print NF}')
890 if [[ -z $DISKSARRAY ]]; then
895 if (( $DISK_ARRAY_NUM == 1 )); then
896 while ((j
< MAX_PARTITIONS
)); do
897 parted
$DEV_DSKDIR/$DISK -s rm $j \
899 if (( $?
== 1 )); then
900 lsblk |
egrep ${DISK}${SLICE_PREFIX}${j} > /dev
/null
901 if (( $?
== 1 )); then
902 log_note
"Partitions for $DISK should be deleted"
904 log_fail
"Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
908 lsblk |
egrep ${DISK}${SLICE_PREFIX}${j} > /dev
/null
909 if (( $?
== 0 )); then
910 log_fail
"Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
916 for disk
in `echo $DISKSARRAY`; do
917 while ((j
< MAX_PARTITIONS
)); do
918 parted
$DEV_DSKDIR/$disk -s rm $j > /dev
/null
2>&1
919 if (( $?
== 1 )); then
920 lsblk |
egrep ${disk}${SLICE_PREFIX}${j} > /dev
/null
921 if (( $?
== 1 )); then
922 log_note
"Partitions for $disk should be deleted"
924 log_fail
"Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
928 lsblk |
egrep ${disk}${SLICE_PREFIX}${j} > /dev
/null
929 if (( $?
== 0 )); then
930 log_fail
"Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
943 # Get the end cyl of the given slice
945 function get_endslice
#<disk> <slice>
949 if [[ -z $disk ||
-z $slice ]] ; then
950 log_fail
"The disk name or slice number is unspecified."
954 endcyl
=$
(parted
-s $DEV_DSKDIR/$disk -- unit cyl print | \
955 grep "part${slice}" | \
958 ((endcyl
= (endcyl
+ 1)))
960 disk
=${disk#/dev/dsk/}
961 disk
=${disk#/dev/rdsk/}
965 ratio
=$
(prtvtoc
/dev
/rdsk
/${disk}s2 | \
966 grep "sectors\/cylinder" | \
969 if ((ratio
== 0)); then
973 typeset
-i endcyl
=$
(prtvtoc
-h /dev
/rdsk
/${disk}s2 |
974 nawk
-v token
="$slice" '{if ($1==token) print $6}')
976 ((endcyl
= (endcyl
+ 1) / ratio
))
984 # Given a size,disk and total slice number, this function formats the
985 # disk slices from 0 to the total slice number with the same specified
988 function partition_disk
#<slice_size> <whole_disk_name> <total_slices>
991 typeset slice_size
=$1
993 typeset total_slices
=$3
996 zero_partitions
$disk_name
997 while ((i
< $total_slices)); do
1004 log_must set_partition
$i "$cyl" $slice_size $disk_name
1005 cyl
=$
(get_endslice
$disk_name $i)
1011 # This function continues to write to a filenum number of files into dirnum
1012 # number of directories until either file_write returns an error or the
1013 # maximum number of files per directory have been written.
1016 # fill_fs [destdir] [dirnum] [filenum] [bytes] [num_writes] [data]
1018 # Return value: 0 on success
1022 # destdir: is the directory where everything is to be created under
1023 # dirnum: the maximum number of subdirectories to use, -1 no limit
1024 # filenum: the maximum number of files per subdirectory
1025 # bytes: number of bytes to write
1026 # num_writes: numer of types to write out bytes
1027 # data: the data that will be written
1030 # file_fs /testdir 20 25 1024 256 0
1032 # Note: bytes * num_writes equals the size of the testfile
1034 function fill_fs
# destdir dirnum filenum bytes num_writes data
1036 typeset destdir
=${1:-$TESTDIR}
1037 typeset
-i dirnum
=${2:-50}
1038 typeset
-i filenum
=${3:-50}
1039 typeset
-i bytes
=${4:-8192}
1040 typeset
-i num_writes
=${5:-10240}
1041 typeset
-i data
=${6:-0}
1043 typeset
-i odirnum
=1
1044 typeset
-i idirnum
=0
1048 log_must mkdir
-p $destdir/$idirnum
1049 while (($odirnum > 0)); do
1050 if ((dirnum
>= 0 && idirnum
>= dirnum
)); then
1054 file_write
-o create
-f $destdir/$idirnum/$TESTFILE.
$fn \
1055 -b $bytes -c $num_writes -d $data
1057 if (($retval != 0)); then
1061 if (($fn >= $filenum)); then
1063 ((idirnum
= idirnum
+ 1))
1064 log_must mkdir
-p $destdir/$idirnum
1073 # Simple function to get the specified property. If unable to
1074 # get the property then exits.
1076 # Note property is in 'parsable' format (-p)
1078 function get_prop
# property dataset
1084 prop_val
=$
(zfs get
-pH -o value
$prop $dataset 2>/dev
/null
)
1085 if [[ $?
-ne 0 ]]; then
1086 log_note
"Unable to get $prop property for dataset " \
1096 # Simple function to get the specified property of pool. If unable to
1097 # get the property then exits.
1099 # Note property is in 'parsable' format (-p)
1101 function get_pool_prop
# property pool
1107 if poolexists
$pool ; then
1108 prop_val
=$
(zpool get
-pH $prop $pool 2>/dev
/null |
tail -1 | \
1110 if [[ $?
-ne 0 ]]; then
1111 log_note
"Unable to get $prop property for pool " \
1116 log_note
"Pool $pool not exists."
1124 # Return 0 if a pool exists; $? otherwise
1132 if [[ -z $pool ]]; then
1133 log_note
"No pool name given."
1137 zpool get name
"$pool" > /dev
/null
2>&1
1141 # Return 0 if all the specified datasets exist; $? otherwise
1144 function datasetexists
1146 if (($# == 0)); then
1147 log_note
"No dataset name given."
1151 while (($# > 0)); do
1152 zfs get name
$1 > /dev
/null
2>&1 || \
1160 # return 0 if none of the specified datasets exists, otherwise return 1.
1163 function datasetnonexists
1165 if (($# == 0)); then
1166 log_note
"No dataset name given."
1170 while (($# > 0)); do
1171 zfs list
-H -t filesystem
,snapshot
,volume
$1 > /dev
/null
2>&1 \
1180 # Given a mountpoint, or a dataset name, determine if it is shared via NFS.
1182 # Returns 0 if shared, 1 otherwise.
1189 if [[ $fs != "/"* ]] ; then
1190 if datasetnonexists
"$fs" ; then
1193 mtpt
=$
(get_prop mountpoint
"$fs")
1195 none|legacy|
-) return 1
1204 for mtpt
in `share | awk '{print $1}'` ; do
1205 if [[ $mtpt == $fs ]] ; then
1212 for mtpt
in `share | awk '{print $2}'` ; do
1213 if [[ $mtpt == $fs ]] ; then
1218 typeset stat
=$
(svcs
-H -o STA nfs
/server
:default
)
1219 if [[ $stat != "ON" ]]; then
1220 log_note
"Current nfs/server status: $stat"
1227 # Given a dataset name determine if it is shared via SMB.
1229 # Returns 0 if shared, 1 otherwise.
1231 function is_shared_smb
1236 if datasetnonexists
"$fs" ; then
1239 fs
=$
(echo $fs |
sed 's@/@_@g')
1243 for mtpt
in `net usershare list | awk '{print $1}'` ; do
1244 if [[ $mtpt == $fs ]] ; then
1250 log_unsupported
"Currently unsupported by the test framework"
1256 # Given a mountpoint, determine if it is not shared via NFS.
1258 # Returns 0 if not shared, 1 otherwise.
1265 if (($?
== 0)); then
1273 # Given a dataset determine if it is not shared via SMB.
1275 # Returns 0 if not shared, 1 otherwise.
1277 function not_shared_smb
1282 if (($?
== 0)); then
1290 # Helper function to unshare a mountpoint.
1292 function unshare_fs
#fs
1296 is_shared
$fs || is_shared_smb
$fs
1297 if (($?
== 0)); then
1298 log_must zfs unshare
$fs
1305 # Helper function to share a NFS mountpoint.
1307 function share_nfs
#fs
1313 if (($?
!= 0)); then
1314 log_must share
"*:$fs"
1318 if (($?
!= 0)); then
1319 log_must share
-F nfs
$fs
1327 # Helper function to unshare a NFS mountpoint.
1329 function unshare_nfs
#fs
1335 if (($?
== 0)); then
1336 log_must unshare
-u "*:$fs"
1340 if (($?
== 0)); then
1341 log_must unshare
-F nfs
$fs
1349 # Helper function to show NFS shares.
1351 function showshares_nfs
1363 # Helper function to show SMB shares.
1365 function showshares_smb
1377 # Check NFS server status and trigger it online.
1379 function setup_nfs_server
1381 # Cannot share directory in non-global zone.
1383 if ! is_global_zone
; then
1384 log_note
"Cannot trigger NFS server by sharing in LZ."
1389 log_note
"NFS server must started prior to running test framework."
1393 typeset nfs_fmri
="svc:/network/nfs/server:default"
1394 if [[ $
(svcs
-Ho STA
$nfs_fmri) != "ON" ]]; then
1396 # Only really sharing operation can enable NFS server
1397 # to online permanently.
1399 typeset dummy
=/tmp
/dummy
1401 if [[ -d $dummy ]]; then
1402 log_must
rm -rf $dummy
1405 log_must mkdir
$dummy
1406 log_must share
$dummy
1409 # Waiting for fmri's status to be the final status.
1410 # Otherwise, in transition, an asterisk (*) is appended for
1411 # instances, unshare will reverse status to 'DIS' again.
1413 # Waiting for 1's at least.
1417 while [[ timeout
-ne 0 && $
(svcs
-Ho STA
$nfs_fmri) == *'*' ]]
1424 log_must unshare
$dummy
1425 log_must
rm -rf $dummy
1428 log_note
"Current NFS status: '$(svcs -Ho STA,FMRI $nfs_fmri)'"
1432 # To verify whether calling process is in global zone
1434 # Return 0 if in global zone, 1 in non-global zone
1436 function is_global_zone
1441 typeset cur_zone
=$
(zonename
2>/dev
/null
)
1442 if [[ $cur_zone != "global" ]]; then
1450 # Verify whether test is permitted to run from
1451 # global zone, local zone, or both
1453 # $1 zone limit, could be "global", "local", or "both"(no limit)
1455 # Return 0 if permitted, otherwise exit with log_unsupported
1457 function verify_runnable
# zone limit
1461 [[ -z $limit ]] && return 0
1463 if is_global_zone
; then
1467 local) log_unsupported
"Test is unable to run from "\
1470 *) log_note
"Warning: unknown limit $limit - " \
1478 global
) log_unsupported
"Test is unable to run from "\
1481 *) log_note
"Warning: unknown limit $limit - " \
1492 # Return 0 if create successfully or the pool exists; $? otherwise
1493 # Note: In local zones, this function should return 0 silently.
1496 # $2-n - [keyword] devs_list
1498 function create_pool
#pool devs_list
1500 typeset pool
=${1%%/*}
1504 if [[ -z $pool ]]; then
1505 log_note
"Missing pool name."
1509 if poolexists
$pool ; then
1513 if is_global_zone
; then
1514 [[ -d /$pool ]] && rm -rf /$pool
1515 log_must zpool create
-f $pool $@
1521 # Return 0 if destroy successfully or the pool exists; $? otherwise
1522 # Note: In local zones, this function should return 0 silently.
1525 # Destroy pool with the given parameters.
1527 function destroy_pool
#pool
1529 typeset pool
=${1%%/*}
1532 if [[ -z $pool ]]; then
1533 log_note
"No pool name given."
1537 if is_global_zone
; then
1538 if poolexists
"$pool" ; then
1539 mtpt
=$
(get_prop mountpoint
"$pool")
1541 # At times, syseventd/udev activity can cause attempts
1542 # to destroy a pool to fail with EBUSY. We retry a few
1543 # times allowing failures before requiring the destroy
1545 log_must_busy zpool destroy
-f $pool
1548 log_must
rm -rf $mtpt
1550 log_note
"Pool does not exist. ($pool)"
1559 # Firstly, create a pool with 5 datasets. Then, create a single zone and
1560 # export the 5 datasets to it. In addition, we also add a ZFS filesystem
1561 # and a zvol device to the zone.
1564 # $2 zone root directory prefix
1567 function zfs_zones_setup
#zone_name zone_root zone_ip
1569 typeset zone_name
=${1:-$(hostname)-z}
1570 typeset zone_root
=${2:-"/zone_root"}
1571 typeset zone_ip
=${3:-"10.1.1.10"}
1572 typeset prefix_ctr
=$ZONE_CTR
1573 typeset pool_name
=$ZONE_POOL
1577 # Create pool and 5 container within it
1579 [[ -d /$pool_name ]] && rm -rf /$pool_name
1580 log_must zpool create
-f $pool_name $DISKS
1581 while ((i
< cntctr
)); do
1582 log_must zfs create
$pool_name/$prefix_ctr$i
1587 log_must zfs create
-V 1g
$pool_name/zone_zvol
1591 # If current system support slog, add slog device for pool
1593 if verify_slog_support
; then
1594 typeset sdevs
="/var/tmp/sdev1 /var/tmp/sdev2"
1595 log_must mkfile
$MINVDEVSIZE $sdevs
1596 log_must zpool add
$pool_name log mirror
$sdevs
1599 # this isn't supported just yet.
1600 # Create a filesystem. In order to add this to
1601 # the zone, it must have it's mountpoint set to 'legacy'
1602 # log_must zfs create $pool_name/zfs_filesystem
1603 # log_must zfs set mountpoint=legacy $pool_name/zfs_filesystem
1605 [[ -d $zone_root ]] && \
1606 log_must
rm -rf $zone_root/$zone_name
1607 [[ ! -d $zone_root ]] && \
1608 log_must mkdir
-p -m 0700 $zone_root/$zone_name
1610 # Create zone configure file and configure the zone
1612 typeset zone_conf
=/tmp
/zone_conf.$$
1613 echo "create" > $zone_conf
1614 echo "set zonepath=$zone_root/$zone_name" >> $zone_conf
1615 echo "set autoboot=true" >> $zone_conf
1617 while ((i
< cntctr
)); do
1618 echo "add dataset" >> $zone_conf
1619 echo "set name=$pool_name/$prefix_ctr$i" >> \
1621 echo "end" >> $zone_conf
1625 # add our zvol to the zone
1626 echo "add device" >> $zone_conf
1627 echo "set match=/dev/zvol/dsk/$pool_name/zone_zvol" >> $zone_conf
1628 echo "end" >> $zone_conf
1630 # add a corresponding zvol rdsk to the zone
1631 echo "add device" >> $zone_conf
1632 echo "set match=$ZVOL_RDEVDIR/$pool_name/zone_zvol" >> $zone_conf
1633 echo "end" >> $zone_conf
1635 # once it's supported, we'll add our filesystem to the zone
1636 # echo "add fs" >> $zone_conf
1637 # echo "set type=zfs" >> $zone_conf
1638 # echo "set special=$pool_name/zfs_filesystem" >> $zone_conf
1639 # echo "set dir=/export/zfs_filesystem" >> $zone_conf
1640 # echo "end" >> $zone_conf
1642 echo "verify" >> $zone_conf
1643 echo "commit" >> $zone_conf
1644 log_must zonecfg
-z $zone_name -f $zone_conf
1645 log_must
rm -f $zone_conf
1648 zoneadm
-z $zone_name install
1649 if (($?
== 0)); then
1650 log_note
"SUCCESS: zoneadm -z $zone_name install"
1652 log_fail
"FAIL: zoneadm -z $zone_name install"
1655 # Install sysidcfg file
1657 typeset sysidcfg
=$zone_root/$zone_name/root
/etc
/sysidcfg
1658 echo "system_locale=C" > $sysidcfg
1659 echo "terminal=dtterm" >> $sysidcfg
1660 echo "network_interface=primary {" >> $sysidcfg
1661 echo "hostname=$zone_name" >> $sysidcfg
1662 echo "}" >> $sysidcfg
1663 echo "name_service=NONE" >> $sysidcfg
1664 echo "root_password=mo791xfZ/SFiw" >> $sysidcfg
1665 echo "security_policy=NONE" >> $sysidcfg
1666 echo "timezone=US/Eastern" >> $sysidcfg
1669 log_must zoneadm
-z $zone_name boot
1673 # Reexport TESTPOOL & TESTPOOL(1-4)
1675 function reexport_pool
1680 while ((i
< cntctr
)); do
1682 TESTPOOL
=$ZONE_POOL/$ZONE_CTR$i
1683 if ! ismounted
$TESTPOOL; then
1684 log_must zfs mount
$TESTPOOL
1687 eval TESTPOOL
$i=$ZONE_POOL/$ZONE_CTR$i
1688 if eval ! ismounted \
$TESTPOOL$i; then
1689 log_must
eval zfs mount \
$TESTPOOL$i
1697 # Verify a given disk or pool state
1699 # Return 0 is pool/disk matches expected state, 1 otherwise
1701 function check_state
# pool disk state{online,offline,degraded}
1704 typeset disk
=${2#$DEV_DSKDIR/}
1707 [[ -z $pool ]] ||
[[ -z $state ]] \
1708 && log_fail
"Arguments invalid or missing"
1710 if [[ -z $disk ]]; then
1711 #check pool state only
1712 zpool get
-H -o value health
$pool \
1713 |
grep -i "$state" > /dev
/null
2>&1
1715 zpool status
-v $pool |
grep "$disk" \
1716 |
grep -i "$state" > /dev
/null
2>&1
1723 # Cause a scan of all scsi host adapters by default
1725 # $1 optional host number
1727 function scan_scsi_hosts
1729 typeset hostnum
=${1}
1732 if [[ -z $hostnum ]]; then
1733 for host in /sys
/class
/scsi_host
/host*; do
1734 log_must
eval "echo '- - -' > $host/scan"
1738 "echo /sys/class/scsi_host/host$hostnum/scan" \
1741 "echo '- - -' > /sys/class/scsi_host/host$hostnum/scan"
1746 # Wait for newly created block devices to have their minors created.
1748 function block_device_wait
1757 # Online or offline a disk on the system
1759 # First checks state of disk. Test will fail if disk is not properly onlined
1760 # or offlined. Online is a full rescan of SCSI disks by echoing to every
1763 function on_off_disk
# disk state{online,offline} host
1769 [[ -z $disk ]] ||
[[ -z $state ]] && \
1770 log_fail
"Arguments invalid or missing"
1773 if [[ $state == "offline" ]] && ( is_mpath_device
$disk ); then
1774 dm_name
="$(readlink $DEV_DSKDIR/$disk \
1775 | nawk -F / '{print $2}')"
1776 slave
="$(ls /sys/block/${dm_name}/slaves \
1777 | nawk '{print $1}')"
1778 while [[ -n $slave ]]; do
1779 #check if disk is online
1780 lsscsi |
egrep $slave > /dev
/null
1781 if (($?
== 0)); then
1782 slave_dir
="/sys/block/${dm_name}"
1783 slave_dir
+="/slaves/${slave}/device"
1784 ss
="${slave_dir}/state"
1785 sd
="${slave_dir}/delete"
1786 log_must
eval "echo 'offline' > ${ss}"
1787 log_must
eval "echo '1' > ${sd}"
1788 lsscsi |
egrep $slave > /dev
/null
1789 if (($?
== 0)); then
1790 log_fail
"Offlining" \
1794 slave
="$(ls /sys/block/$dm_name/slaves \
1795 2>/dev/null | nawk '{print $1}')"
1797 elif [[ $state == "offline" ]] && ( is_real_device
$disk ); then
1798 #check if disk is online
1799 lsscsi |
egrep $disk > /dev
/null
1800 if (($?
== 0)); then
1801 dev_state
="/sys/block/$disk/device/state"
1802 dev_delete
="/sys/block/$disk/device/delete"
1803 log_must
eval "echo 'offline' > ${dev_state}"
1804 log_must
eval "echo '1' > ${dev_delete}"
1805 lsscsi |
egrep $disk > /dev
/null
1806 if (($?
== 0)); then
1807 log_fail
"Offlining $disk" \
1811 log_note
"$disk is already offline"
1813 elif [[ $state == "online" ]]; then
1814 #force a full rescan
1815 scan_scsi_hosts
$host
1817 if is_mpath_device
$disk; then
1818 dm_name
="$(readlink $DEV_DSKDIR/$disk \
1819 | nawk -F / '{print $2}')"
1820 slave
="$(ls /sys/block/$dm_name/slaves \
1821 | nawk '{print $1}')"
1822 lsscsi |
egrep $slave > /dev
/null
1823 if (($?
!= 0)); then
1824 log_fail
"Onlining $disk failed"
1826 elif is_real_device
$disk; then
1827 lsscsi |
egrep $disk > /dev
/null
1828 if (($?
!= 0)); then
1829 log_fail
"Onlining $disk failed"
1832 log_fail
"$disk is not a real dev"
1835 log_fail
"$disk failed to $state"
1841 # Get the mountpoint of snapshot
1842 # For the snapshot use <mp_filesystem>/.zfs/snapshot/<snap>
1845 function snapshot_mountpoint
1847 typeset dataset
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
1849 if [[ $dataset != *@
* ]]; then
1850 log_fail
"Error name of snapshot '$dataset'."
1853 typeset fs
=${dataset%@*}
1854 typeset snap
=${dataset#*@}
1856 if [[ -z $fs ||
-z $snap ]]; then
1857 log_fail
"Error name of snapshot '$dataset'."
1860 echo $
(get_prop mountpoint
$fs)/.zfs
/snapshot
/$snap
1864 # Given a device and 'ashift' value verify it's correctly set on every label
1866 function verify_ashift
# device ashift
1871 zdb
-e -lll $device |
awk -v ashift
=$ashift '/ashift: / {
1887 # Given a pool and file system, this function will verify the file system
1888 # using the zdb internal tool. Note that the pool is exported and imported
1889 # to ensure it has consistent state.
1891 function verify_filesys
# pool filesystem dir
1894 typeset filesys
="$2"
1895 typeset zdbout
="/tmp/zdbout.$$"
1900 typeset search_path
=""
1902 log_note
"Calling zdb to verify filesystem '$filesys'"
1903 zfs unmount
-a > /dev
/null
2>&1
1904 log_must zpool
export $pool
1906 if [[ -n $dirs ]] ; then
1907 for dir
in $dirs ; do
1908 search_path
="$search_path -d $dir"
1912 log_must zpool import
$search_path $pool
1914 zdb
-cudi $filesys > $zdbout 2>&1
1915 if [[ $?
!= 0 ]]; then
1916 log_note
"Output: zdb -cudi $filesys"
1918 log_fail
"zdb detected errors with: '$filesys'"
1921 log_must zfs mount
-a
1922 log_must
rm -rf $zdbout
1926 # Given a pool, and this function list all disks in the pool
1928 function get_disklist
# pool
1932 disklist
=$
(zpool iostat
-v $1 | nawk
'(NR >4) {print $1}' | \
1933 grep -v "\-\-\-\-\-" | \
1934 egrep -v -e "^(mirror|raidz1|raidz2|spare|log|cache)$")
1940 # Given a pool, and this function list all disks in the pool with their full
1941 # path (like "/dev/sda" instead of "sda").
1943 function get_disklist_fullpath
# pool
1952 # This function kills a given list of processes after a time period. We use
1953 # this in the stress tests instead of STF_TIMEOUT so that we can have processes
1954 # run for a fixed amount of time, yet still pass. Tests that hit STF_TIMEOUT
1955 # would be listed as FAIL, which we don't want : we're happy with stress tests
1956 # running for a certain amount of time, then finishing.
1958 # @param $1 the time in seconds after which we should terminate these processes
1959 # @param $2..$n the processes we wish to terminate.
1961 function stress_timeout
1963 typeset
-i TIMEOUT
=$1
1967 log_note
"Waiting for child processes($cpids). " \
1968 "It could last dozens of minutes, please be patient ..."
1969 log_must
sleep $TIMEOUT
1971 log_note
"Killing child processes after ${TIMEOUT} stress timeout."
1973 for pid
in $cpids; do
1974 ps
-p $pid > /dev
/null
2>&1
1975 if (($?
== 0)); then
1976 log_must
kill -USR1 $pid
1982 # Verify a given hotspare disk is inuse or avail
1984 # Return 0 is pool/disk matches expected state, 1 otherwise
1986 function check_hotspare_state
# pool disk state{inuse,avail}
1989 typeset disk
=${2#$DEV_DSKDIR/}
1992 cur_state
=$
(get_device_state
$pool $disk "spares")
1994 if [[ $state != ${cur_state} ]]; then
2001 # Wait until a hotspare transitions to a given state or times out.
2003 # Return 0 when pool/disk matches expected state, 1 on timeout.
2005 function wait_hotspare_state
# pool disk state timeout
2008 typeset disk
=${2#$/DEV_DSKDIR/}
2010 typeset timeout
=${4:-60}
2013 while [[ $i -lt $timeout ]]; do
2014 if check_hotspare_state
$pool $disk $state; then
2026 # Verify a given slog disk is inuse or avail
2028 # Return 0 is pool/disk matches expected state, 1 otherwise
2030 function check_slog_state
# pool disk state{online,offline,unavail}
2033 typeset disk
=${2#$DEV_DSKDIR/}
2036 cur_state
=$
(get_device_state
$pool $disk "logs")
2038 if [[ $state != ${cur_state} ]]; then
2045 # Verify a given vdev disk is inuse or avail
2047 # Return 0 is pool/disk matches expected state, 1 otherwise
2049 function check_vdev_state
# pool disk state{online,offline,unavail}
2052 typeset disk
=${2#$/DEV_DSKDIR/}
2055 cur_state
=$
(get_device_state
$pool $disk)
2057 if [[ $state != ${cur_state} ]]; then
2064 # Wait until a vdev transitions to a given state or times out.
2066 # Return 0 when pool/disk matches expected state, 1 on timeout.
2068 function wait_vdev_state
# pool disk state timeout
2071 typeset disk
=${2#$/DEV_DSKDIR/}
2073 typeset timeout
=${4:-60}
2076 while [[ $i -lt $timeout ]]; do
2077 if check_vdev_state
$pool $disk $state; then
2089 # Check the output of 'zpool status -v <pool>',
2090 # and to see if the content of <token> contain the <keyword> specified.
2092 # Return 0 is contain, 1 otherwise
2094 function check_pool_status
# pool token keyword <verbose>
2099 typeset verbose
=${4:-false}
2101 scan
=$
(zpool status
-v "$pool" 2>/dev
/null | nawk
-v token
="$token:" '
2102 ($1==token) {print $0}')
2103 if [[ $verbose == true
]]; then
2106 echo $scan |
grep -i "$keyword" > /dev
/null
2>&1
2112 # These 6 following functions are instance of check_pool_status()
2113 # is_pool_resilvering - to check if the pool is resilver in progress
2114 # is_pool_resilvered - to check if the pool is resilver completed
2115 # is_pool_scrubbing - to check if the pool is scrub in progress
2116 # is_pool_scrubbed - to check if the pool is scrub completed
2117 # is_pool_scrub_stopped - to check if the pool is scrub stopped
2118 # is_pool_scrub_paused - to check if the pool has scrub paused
2120 function is_pool_resilvering
#pool <verbose>
2122 check_pool_status
"$1" "scan" "resilver in progress since " $2
2126 function is_pool_resilvered
#pool <verbose>
2128 check_pool_status
"$1" "scan" "resilvered " $2
2132 function is_pool_scrubbing
#pool <verbose>
2134 check_pool_status
"$1" "scan" "scrub in progress since " $2
2138 function is_pool_scrubbed
#pool <verbose>
2140 check_pool_status
"$1" "scan" "scrub repaired" $2
2144 function is_pool_scrub_stopped
#pool <verbose>
2146 check_pool_status
"$1" "scan" "scrub canceled" $2
2150 function is_pool_scrub_paused
#pool <verbose>
2152 check_pool_status
"$1" "scan" "scrub paused since " $2
2157 # Use create_pool()/destroy_pool() to clean up the information in
2158 # in the given disk to avoid slice overlapping.
2160 function cleanup_devices
#vdevs
2162 typeset pool
="foopool$$"
2164 if poolexists
$pool ; then
2168 create_pool
$pool $@
2175 # A function to find and locate free disks on a system or from given
2176 # disks as the parameter. It works by locating disks that are in use
2177 # as swap devices and dump devices, and also disks listed in /etc/vfstab
2179 # $@ given disks to find which are free, default is all disks in
2182 # @return a string containing the list of available disks
2186 # Trust provided list, no attempt is made to locate unused devices.
2193 sfi
=/tmp
/swaplist.$$
2194 dmpi
=/tmp
/dumpdev.$$
2195 max_finddisksnum
=${MAX_FINDDISKSNUM:-6}
2198 dumpadm
> $dmpi 2>/dev
/null
2200 # write an awk script that can process the output of format
2201 # to produce a list of disks we know about. Note that we have
2202 # to escape "$2" so that the shell doesn't interpret it while
2203 # we're creating the awk script.
2204 # -------------------
2205 cat > /tmp
/find_disks.
awk <<EOF
2214 if (searchdisks && \$2 !~ "^$"){
2220 /^AVAILABLE DISK SELECTIONS:/{
2224 #---------------------
2226 chmod 755 /tmp
/find_disks.
awk
2227 disks
=${@:-$(echo "" | format -e 2>/dev/null | /tmp/find_disks.awk)}
2228 rm /tmp
/find_disks.
awk
2231 for disk
in $disks; do
2233 grep "${disk}[sp]" /etc
/mnttab
>/dev
/null
2234 (($?
== 0)) && continue
2236 grep "${disk}[sp]" $sfi >/dev
/null
2237 (($?
== 0)) && continue
2238 # check for dump device
2239 grep "${disk}[sp]" $dmpi >/dev
/null
2240 (($?
== 0)) && continue
2241 # check to see if this disk hasn't been explicitly excluded
2242 # by a user-set environment variable
2243 echo "${ZFS_HOST_DEVICES_IGNORE}" |
grep "${disk}" > /dev
/null
2244 (($?
== 0)) && continue
2245 unused_candidates
="$unused_candidates $disk"
2250 # now just check to see if those disks do actually exist
2251 # by looking for a device pointing to the first slice in
2252 # each case. limit the number to max_finddisksnum
2254 for disk
in $unused_candidates; do
2255 if [ -b $DEV_DSKDIR/${disk}s0
]; then
2256 if [ $count -lt $max_finddisksnum ]; then
2257 unused
="$unused $disk"
2258 # do not impose limit if $@ is provided
2259 [[ -z $@
]] && ((count
= count
+ 1))
2264 # finally, return our disk list
2269 # Add specified user to specified group
2273 # $3 base of the homedir (optional)
2275 function add_user
#<group_name> <user_name> <basedir>
2279 typeset basedir
=${3:-"/var/tmp"}
2281 if ((${#gname} == 0 ||
${#uname} == 0)); then
2282 log_fail
"group name or user name are not defined."
2285 log_must useradd
-g $gname -d $basedir/$uname -m $uname
2286 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.profile
2287 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.bash_profile
2288 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.login
2290 # Add new users to the same group and the command line utils.
2291 # This allows them to be run out of the original users home
2292 # directory as long as it permissioned to be group readable.
2294 cmd_group
=$
(stat
--format="%G" $
(which zfs
))
2295 log_must usermod
-a -G $cmd_group $uname
2302 # Delete the specified user.
2305 # $2 base of the homedir (optional)
2307 function del_user
#<logname> <basedir>
2310 typeset basedir
=${2:-"/var/tmp"}
2312 if ((${#user} == 0)); then
2313 log_fail
"login name is necessary."
2316 if id
$user > /dev
/null
2>&1; then
2317 log_must_retry
"currently used" 5 userdel
$user
2320 [[ -d $basedir/$user ]] && rm -fr $basedir/$user
2326 # Select valid gid and create specified group.
2330 function add_group
#<group_name>
2334 if ((${#group} == 0)); then
2335 log_fail
"group name is necessary."
2338 # Assign 100 as the base gid, a larger value is selected for
2339 # Linux because for many distributions 1000 and under are reserved.
2342 groupadd
$group > /dev
/null
2>&1
2352 groupadd
-g $gid $group > /dev
/null
2>&1
2356 # The gid is not unique
2365 # Delete the specified group.
2369 function del_group
#<group_name>
2372 if ((${#grp} == 0)); then
2373 log_fail
"group name is necessary."
2377 getent group
$grp > /dev
/null
2>&1
2380 # Group does not exist.
2382 # Name already exists as a group name
2383 0) log_must groupdel
$grp ;;
2387 groupmod
-n $grp $grp > /dev
/null
2>&1
2390 # Group does not exist.
2392 # Name already exists as a group name
2393 9) log_must groupdel
$grp ;;
2402 # This function will return true if it's safe to destroy the pool passed
2403 # as argument 1. It checks for pools based on zvols and files, and also
2404 # files contained in a pool that may have a different mountpoint.
2406 function safe_to_destroy_pool
{ # $1 the pool name
2409 typeset DONT_DESTROY
=""
2411 # We check that by deleting the $1 pool, we're not
2412 # going to pull the rug out from other pools. Do this
2413 # by looking at all other pools, ensuring that they
2414 # aren't built from files or zvols contained in this pool.
2416 for pool
in $
(zpool list
-H -o name
)
2420 # this is a list of the top-level directories in each of the
2421 # files that make up the path to the files the pool is based on
2422 FILEPOOL
=$
(zpool status
-v $pool |
grep /$1/ | \
2425 # this is a list of the zvols that make up the pool
2426 ZVOLPOOL
=$
(zpool status
-v $pool |
grep "$ZVOL_DEVDIR/$1$" \
2429 # also want to determine if it's a file-based pool using an
2430 # alternate mountpoint...
2431 POOL_FILE_DIRS
=$
(zpool status
-v $pool | \
2432 grep / |
awk '{print $1}' | \
2433 awk -F/ '{print $2}' |
grep -v "dev")
2435 for pooldir
in $POOL_FILE_DIRS
2437 OUTPUT
=$
(zfs list
-H -r -o mountpoint
$1 | \
2438 grep "${pooldir}$" |
awk '{print $1}')
2440 ALTMOUNTPOOL
="${ALTMOUNTPOOL}${OUTPUT}"
2444 if [ ! -z "$ZVOLPOOL" ]
2447 log_note
"Pool $pool is built from $ZVOLPOOL on $1"
2450 if [ ! -z "$FILEPOOL" ]
2453 log_note
"Pool $pool is built from $FILEPOOL on $1"
2456 if [ ! -z "$ALTMOUNTPOOL" ]
2459 log_note
"Pool $pool is built from $ALTMOUNTPOOL on $1"
2463 if [ -z "${DONT_DESTROY}" ]
2467 log_note
"Warning: it is not safe to destroy $1!"
2473 # Get the available ZFS compression options
2474 # $1 option type zfs_set|zfs_compress
2476 function get_compress_opts
2478 typeset COMPRESS_OPTS
2479 typeset GZIP_OPTS
="gzip gzip-1 gzip-2 gzip-3 gzip-4 gzip-5 \
2480 gzip-6 gzip-7 gzip-8 gzip-9"
2482 if [[ $1 == "zfs_compress" ]] ; then
2483 COMPRESS_OPTS
="on lzjb"
2484 elif [[ $1 == "zfs_set" ]] ; then
2485 COMPRESS_OPTS
="on off lzjb"
2487 typeset valid_opts
="$COMPRESS_OPTS"
2488 zfs get
2>&1 |
grep gzip >/dev
/null
2>&1
2489 if [[ $?
-eq 0 ]]; then
2490 valid_opts
="$valid_opts $GZIP_OPTS"
2496 # Verify zfs operation with -p option work as expected
2497 # $1 operation, value could be create, clone or rename
2498 # $2 dataset type, value could be fs or vol
2500 # $4 new dataset name
2502 function verify_opt_p_ops
2507 typeset newdataset
=$4
2509 if [[ $datatype != "fs" && $datatype != "vol" ]]; then
2510 log_fail
"$datatype is not supported."
2513 # check parameters accordingly
2518 if [[ $datatype == "vol" ]]; then
2519 ops
="create -V $VOLSIZE"
2523 if [[ -z $newdataset ]]; then
2524 log_fail
"newdataset should not be empty" \
2527 log_must datasetexists
$dataset
2528 log_must snapexists
$dataset
2531 if [[ -z $newdataset ]]; then
2532 log_fail
"newdataset should not be empty" \
2535 log_must datasetexists
$dataset
2536 log_mustnot snapexists
$dataset
2539 log_fail
"$ops is not supported."
2543 # make sure the upper level filesystem does not exist
2544 if datasetexists
${newdataset%/*} ; then
2545 log_must zfs destroy
-rRf ${newdataset%/*}
2548 # without -p option, operation will fail
2549 log_mustnot zfs
$ops $dataset $newdataset
2550 log_mustnot datasetexists
$newdataset ${newdataset%/*}
2552 # with -p option, operation should succeed
2553 log_must zfs
$ops -p $dataset $newdataset
2556 if ! datasetexists
$newdataset ; then
2557 log_fail
"-p option does not work for $ops"
2560 # when $ops is create or clone, redo the operation still return zero
2561 if [[ $ops != "rename" ]]; then
2562 log_must zfs
$ops -p $dataset $newdataset
2569 # Get configuration of pool
2579 if ! poolexists
"$pool" ; then
2582 alt_root
=$
(zpool list
-H $pool |
awk '{print $NF}')
2583 if [[ $alt_root == "-" ]]; then
2584 value
=$
(zdb
-C $pool |
grep "$config:" |
awk -F: \
2587 value
=$
(zdb
-e $pool |
grep "$config:" |
awk -F: \
2590 if [[ -n $value ]] ; then
2600 # Privated function. Random select one of items from arguments.
2605 function _random_get
2612 ((ind
= RANDOM
% cnt
+ 1))
2614 typeset ret
=$
(echo "$str" | cut
-f $ind -d ' ')
2619 # Random select one of item from arguments which include NONE string
2621 function random_get_with_non
2626 _random_get
"$cnt" "$@"
2630 # Random select one of item from arguments which doesn't include NONE string
2634 _random_get
"$#" "$@"
2638 # Detect if the current system support slog
2640 function verify_slog_support
2642 typeset dir
=/tmp
/disk.$$
2648 mkfile
$MINVDEVSIZE $vdev $sdev
2651 if ! zpool create
-n $pool $vdev log
$sdev > /dev
/null
2>&1; then
2660 # The function will generate a dataset name with specific length
2661 # $1, the length of the name
2662 # $2, the base string to construct the name
2664 function gen_dataset_name
2667 typeset basestr
="$2"
2668 typeset
-i baselen
=${#basestr}
2672 if ((len
% baselen
== 0)); then
2673 ((iter
= len
/ baselen
))
2675 ((iter
= len
/ baselen
+ 1))
2677 while ((iter
> 0)); do
2678 l_name
="${l_name}$basestr"
2687 # Get cksum tuple of dataset
2690 # sample zdb output:
2691 # Dataset data/test [ZPL], ID 355, cr_txg 2413856, 31.0K, 7 objects, rootbp
2692 # DVA[0]=<0:803046400:200> DVA[1]=<0:81199000:200> [L0 DMU objset] fletcher4
2693 # lzjb LE contiguous unique double size=800L/200P birth=2413856L/2413856P
2694 # fill=7 cksum=11ce125712:643a9c18ee2:125e25238fca0:254a3f74b59744
2695 function datasetcksum
2699 cksum=$
(zdb
-vvv $1 |
grep "^Dataset $1 \[" |
grep "cksum" \
2700 |
awk -F= '{print $7}')
2711 cksum=$
(cksum $1 |
awk '{print $1}')
2716 # Get the given disk/slice state from the specific field of the pool
2718 function get_device_state
#pool disk field("", "spares","logs")
2721 typeset disk
=${2#$DEV_DSKDIR/}
2722 typeset field
=${3:-$pool}
2724 state
=$
(zpool status
-v "$pool" 2>/dev
/null | \
2725 nawk
-v device
=$disk -v pool
=$pool -v field
=$field \
2726 'BEGIN {startconfig=0; startfield=0; }
2727 /config:/ {startconfig=1}
2728 (startconfig==1) && ($1==field) {startfield=1; next;}
2729 (startfield==1) && ($1==device) {print $2; exit;}
2731 ($1==field || $1 ~ "^spares$" || $1 ~ "^logs$") {startfield=0}')
2737 # print the given directory filesystem type
2745 if [[ -z $dir ]]; then
2746 log_fail
"Usage: get_fstype <directory>"
2753 df
-n $dir |
awk '{print $3}'
2757 # Given a disk, label it to VTOC regardless what label was on the disk
2763 if [[ -z $disk ]]; then
2764 log_fail
"The disk name is unspecified."
2766 typeset label_file
=/var
/tmp
/labelvtoc.$$
2767 typeset arch
=$
(uname
-p)
2770 log_note
"Currently unsupported by the test framework"
2774 if [[ $arch == "i386" ]]; then
2775 echo "label" > $label_file
2776 echo "0" >> $label_file
2777 echo "" >> $label_file
2778 echo "q" >> $label_file
2779 echo "q" >> $label_file
2781 fdisk
-B $disk >/dev
/null
2>&1
2782 # wait a while for fdisk finishes
2784 elif [[ $arch == "sparc" ]]; then
2785 echo "label" > $label_file
2786 echo "0" >> $label_file
2787 echo "" >> $label_file
2788 echo "" >> $label_file
2789 echo "" >> $label_file
2790 echo "q" >> $label_file
2792 log_fail
"unknown arch type"
2795 format
-e -s -d $disk -f $label_file
2796 typeset
-i ret_val
=$?
2799 # wait the format to finish
2802 if ((ret_val
!= 0)); then
2803 log_fail
"unable to label $disk as VTOC."
2810 # check if the system was installed as zfsroot or not
2811 # return: 0 ture, otherwise false
2815 df
-n / |
grep zfs
> /dev
/null
2>&1
2820 # get the root filesystem name if it's zfsroot system.
2822 # return: root filesystem name
2828 rootfs
=$
(awk '{if ($2 == "/" && $3 == "zfs") print $1}' \
2831 if [[ -z "$rootfs" ]]; then
2832 log_fail
"Can not get rootfs"
2834 zfs list
$rootfs > /dev
/null
2>&1
2835 if (($?
== 0)); then
2838 log_fail
"This is not a zfsroot system."
2843 # get the rootfs's pool name
2847 function get_rootpool
2853 rootfs
=$
(awk '{if ($2 == "/" && $3 =="zfs") print $1}' \
2856 if [[ -z "$rootfs" ]]; then
2857 log_fail
"Can not get rootpool"
2859 zfs list
$rootfs > /dev
/null
2>&1
2860 if (($?
== 0)); then
2861 rootpool
=`echo $rootfs | awk -F\/ '{print $1}'`
2864 log_fail
"This is not a zfsroot system."
2869 # Check if the given device is physical device
2871 function is_physical_device
#device
2873 typeset device
=${1#$DEV_DSKDIR}
2874 device
=${device#$DEV_RDSKDIR}
2877 [[ -b "$DEV_DSKDIR/$device" ]] && \
2878 [[ -f /sys
/module
/loop
/parameters
/max_part
]]
2881 echo $device |
egrep "^c[0-F]+([td][0-F]+)+$" > /dev
/null
2>&1
2887 # Check if the given device is a real device (ie SCSI device)
2889 function is_real_device
#disk
2892 [[ -z $disk ]] && log_fail
"No argument for disk given."
2895 lsblk
$DEV_RDSKDIR/$disk -o TYPE
2>/dev
/null | \
2896 egrep disk
>/dev
/null
2902 # Check if the given device is a loop device
2904 function is_loop_device
#disk
2907 [[ -z $disk ]] && log_fail
"No argument for disk given."
2910 lsblk
$DEV_RDSKDIR/$disk -o TYPE
2>/dev
/null | \
2911 egrep loop
>/dev
/null
2917 # Check if the given device is a multipath device and if there is a sybolic
2918 # link to a device mapper and to a disk
2919 # Currently no support for dm devices alone without multipath
2921 function is_mpath_device
#disk
2924 [[ -z $disk ]] && log_fail
"No argument for disk given."
2927 lsblk
$DEV_MPATHDIR/$disk -o TYPE
2>/dev
/null | \
2928 egrep mpath
>/dev
/null
2929 if (($?
== 0)); then
2930 readlink
$DEV_MPATHDIR/$disk > /dev
/null
2>&1
2938 # Set the slice prefix for disk partitioning depending
2939 # on whether the device is a real, multipath, or loop device.
2940 # Currently all disks have to be of the same type, so only
2941 # checks first disk to determine slice prefix.
2943 function set_slice_prefix
2949 while (( i
< $DISK_ARRAY_NUM )); do
2950 disk
="$(echo $DISKS | nawk '{print $(i + 1)}')"
2951 if ( is_mpath_device
$disk ) && [[ -z $
(echo $disk |
awk 'substr($1,18,1)\
2952 ~ /^[[:digit:]]+$/') ]] ||
( is_real_device
$disk ); then
2953 export SLICE_PREFIX
=""
2955 elif ( is_mpath_device
$disk || is_loop_device \
2957 export SLICE_PREFIX
="p"
2960 log_fail
"$disk not supported for partitioning."
2968 # Set the directory path of the listed devices in $DISK_ARRAY_NUM
2969 # Currently all disks have to be of the same type, so only
2970 # checks first disk to determine device directory
2971 # default = /dev (linux)
2972 # real disk = /dev (linux)
2973 # multipath device = /dev/mapper (linux)
2975 function set_device_dir
2981 while (( i
< $DISK_ARRAY_NUM )); do
2982 disk
="$(echo $DISKS | nawk '{print $(i + 1)}')"
2983 if is_mpath_device
$disk; then
2984 export DEV_DSKDIR
=$DEV_MPATHDIR
2987 export DEV_DSKDIR
=$DEV_RDSKDIR
2993 export DEV_DSKDIR
=$DEV_RDSKDIR
2998 # Get the directory path of given device
3000 function get_device_dir
#device
3004 if ! $
(is_physical_device
$device) ; then
3005 if [[ $device != "/" ]]; then
3008 if [[ -b "$DEV_DSKDIR/$device" ]]; then
3009 device
="$DEV_DSKDIR"
3018 # Get persistent name for given disk
3020 function get_persistent_disk_name
#device
3026 if is_real_device
$device; then
3027 dev_id
="$(udevadm info -q all -n $DEV_DSKDIR/$device \
3028 | egrep disk/by-id | nawk '{print $2; exit}' \
3029 | nawk -F / '{print $3}')"
3031 elif is_mpath_device
$device; then
3032 dev_id
="$(udevadm info -q all -n $DEV_DSKDIR/$device \
3033 | egrep disk/by-id/dm-uuid \
3034 | nawk '{print $2; exit}' \
3035 | nawk -F / '{print $3}')"
3046 # Load scsi_debug module with specified parameters
3048 function load_scsi_debug
# dev_size_mb add_host num_tgts max_luns
3055 [[ -z $devsize ]] ||
[[ -z $hosts ]] ||
[[ -z $tgts ]] || \
3056 [[ -z $luns ]] && log_fail
"Arguments invalid or missing"
3059 modprobe
-n scsi_debug
3060 if (($?
!= 0)); then
3061 log_unsupported
"Platform does not have scsi_debug"
3064 lsmod |
egrep scsi_debug
> /dev
/null
3065 if (($?
== 0)); then
3066 log_fail
"scsi_debug module already installed"
3068 log_must modprobe scsi_debug dev_size_mb
=$devsize \
3069 add_host
=$hosts num_tgts
=$tgts max_luns
=$luns
3071 lsscsi |
egrep scsi_debug
> /dev
/null
3072 if (($?
== 1)); then
3073 log_fail
"scsi_debug module install failed"
3080 # Get the package name
3082 function get_package_name
3084 typeset dirpath
=${1:-$STC_NAME}
3086 echo "SUNWstc-${dirpath}" |
/usr
/bin
/sed -e "s/\//-/g"
3090 # Get the word numbers from a string separated by white space
3092 function get_word_count
3098 # To verify if the require numbers of disks is given
3100 function verify_disk_count
3102 typeset
-i min
=${2:-1}
3104 typeset
-i count
=$
(get_word_count
"$1")
3106 if ((count
< min
)); then
3107 log_untested
"A minimum of $min disks is required to run." \
3108 " You specified $count disk(s)"
3112 function ds_is_volume
3114 typeset
type=$
(get_prop
type $1)
3115 [[ $type = "volume" ]] && return 0
3119 function ds_is_filesystem
3121 typeset
type=$
(get_prop
type $1)
3122 [[ $type = "filesystem" ]] && return 0
3126 function ds_is_snapshot
3128 typeset
type=$
(get_prop
type $1)
3129 [[ $type = "snapshot" ]] && return 0
3134 # Check if Trusted Extensions are installed and enabled
3136 function is_te_enabled
3138 svcs
-H -o state labeld
2>/dev
/null |
grep "enabled"
3139 if (($?
!= 0)); then
3146 # Utility function to determine if a system has multiple cpus.
3152 (($
(psrinfo |
wc -l) > 1))
3158 function get_cpu_freq
3161 lscpu |
awk '/CPU MHz/ { print $3 }'
3163 psrinfo
-v 0 |
awk '/processor operates at/ {print $6}'
3167 # Run the given command as the user provided.
3173 log_note
"user:$user $@"
3174 eval su
- \
$user -c \"$@
\" > /tmp
/out
2>/tmp
/err
3179 # Check if the pool contains the specified vdevs
3184 # Return 0 if the vdevs are contained in the pool, 1 if any of the specified
3185 # vdevs is not in the pool, and 2 if pool name is missing.
3187 function vdevs_in_pool
3192 if [[ -z $pool ]]; then
3193 log_note
"Missing pool name."
3199 typeset tmpfile
=$
(mktemp
)
3200 zpool list
-Hv "$pool" >$tmpfile
3202 grep -w ${vdev##*/} $tmpfile >/dev
/null
2>&1
3203 [[ $?
-ne 0 ]] && return 1
3217 max
=$
(echo $
((max
> i ? max
: i
)))
3229 min
=$
(echo $
((min
< i ? min
: i
)))
3236 # Generate a random number between 1 and the argument.
3241 echo $
(( ($RANDOM % $max) + 1 ))
3244 # Write data that can be compressed into a directory
3245 function write_compressible
3249 typeset nfiles
=${3:-1}
3250 typeset bs
=${4:-1024k}
3251 typeset fname
=${5:-file}
3253 [[ -d $dir ]] || log_fail
"No directory: $dir"
3255 # Under Linux fio is not currently used since its behavior can
3256 # differ significantly across versions. This includes missing
3257 # command line options and cases where the --buffer_compress_*
3258 # options fail to behave as expected.
3260 typeset file_bytes
=$
(to_bytes
$megs)
3261 typeset bs_bytes
=4096
3262 typeset blocks
=$
(($file_bytes / $bs_bytes))
3264 for (( i
= 0; i
< $nfiles; i
++ )); do
3265 truncate
-s $file_bytes $dir/$fname.
$i
3267 # Write every third block to get 66% compression.
3268 for (( j
= 0; j
< $blocks; j
+= 3 )); do
3269 dd if=/dev
/urandom of
=$dir/$fname.
$i \
3270 seek
=$j bs
=$bs_bytes count
=1 \
3271 conv
=notrunc
>/dev
/null
2>&1
3275 log_must
eval "fio \
3280 --buffer_compress_percentage=66 \
3281 --buffer_compress_chunk=4096 \
3288 --filename_format='$fname.\$jobnum' >/dev/null"
3297 [[ -e $pathname ]] || log_fail
"No such file or directory: $pathname"
3298 objnum
=$
(stat
-c %i
$pathname)
3303 # Sync data to the pool
3306 # $2 boolean to force uberblock (and config including zpool cache file) update
3308 function sync_pool
#pool <force>
3310 typeset pool
=${1:-$TESTPOOL}
3311 typeset force
=${2:-false}
3313 if [[ $force == true
]]; then
3314 log_must zpool sync
-f $pool
3316 log_must zpool sync
$pool
3323 # Wait for zpool 'freeing' property drops to zero.
3327 function wait_freeing
#pool
3329 typeset pool
=${1:-$TESTPOOL}
3331 [[ "0" == "$(zpool list -Ho freeing $pool)" ]] && break
3337 # Wait for every device replace operation to complete
3341 function wait_replacing
#pool
3343 typeset pool
=${1:-$TESTPOOL}
3345 [[ "" == "$(zpool status $pool |
3346 awk '/replacing-[0-9]+/ {print $1}')" ]] && break
3352 # Wait for a pool to be scrubbed
3355 # $2 number of seconds to wait (optional)
3357 # Returns true when pool has been scrubbed, or false if there's a timeout or if
3358 # no scrub was done.
3360 function wait_scrubbed
3362 typeset pool
=${1:-$TESTPOOL}
3363 typeset iter
=${2:-10}
3364 for i
in {1..
$iter} ; do
3365 if is_pool_scrubbed
$pool ; then
3374 # Setup custom environment for the ZED.
3376 # $@ Optional list of zedlets to run under zed.
3383 if [[ ! -d $ZEDLET_DIR ]]; then
3384 log_must mkdir
$ZEDLET_DIR
3387 if [[ ! -e $VDEVID_CONF ]]; then
3388 log_must
touch $VDEVID_CONF
3391 if [[ -e $VDEVID_CONF_ETC ]]; then
3392 log_fail
"Must not have $VDEVID_CONF_ETC file present on system"
3396 # Create a symlink for /etc/zfs/vdev_id.conf file.
3397 log_must
ln -s $VDEVID_CONF $VDEVID_CONF_ETC
3399 # Setup minimal ZED configuration. Individual test cases should
3400 # add additional ZEDLETs as needed for their specific test.
3401 log_must
cp ${ZEDLET_ETC_DIR}/zed.rc
$ZEDLET_DIR
3402 log_must
cp ${ZEDLET_ETC_DIR}/zed-functions.sh
$ZEDLET_DIR
3404 # Scripts must only be user writable.
3405 if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3406 saved_umask
=$
(umask)
3408 for i
in $EXTRA_ZEDLETS ; do
3409 log_must
cp ${ZEDLET_LIBEXEC_DIR}/$i $ZEDLET_DIR
3411 log_must
umask $saved_umask
3414 # Customize the zed.rc file to enable the full debug log.
3415 log_must
sed -i '/\#ZED_DEBUG_LOG=.*/d' $ZEDLET_DIR/zed.rc
3416 echo "ZED_DEBUG_LOG=$ZED_DEBUG_LOG" >>$ZEDLET_DIR/zed.rc
3421 # Cleanup custom ZED environment.
3423 # $@ Optional list of zedlets to remove from our test zed.d directory.
3424 function zed_cleanup
3431 log_must
rm -f ${ZEDLET_DIR}/zed.rc
3432 log_must
rm -f ${ZEDLET_DIR}/zed-functions.sh
3433 log_must
rm -f ${ZEDLET_DIR}/all-syslog.sh
3434 log_must
rm -f ${ZEDLET_DIR}/all-debug.sh
3435 log_must
rm -f ${ZEDLET_DIR}/state
3437 if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3438 for i
in $EXTRA_ZEDLETS ; do
3439 log_must
rm -f ${ZEDLET_DIR}/$i
3442 log_must
rm -f $ZED_LOG
3443 log_must
rm -f $ZED_DEBUG_LOG
3444 log_must
rm -f $VDEVID_CONF_ETC
3445 log_must
rm -f $VDEVID_CONF
3450 # Check if ZED is currently running, if not start ZED.
3458 # ZEDLET_DIR=/var/tmp/zed
3459 if [[ ! -d $ZEDLET_DIR ]]; then
3460 log_must mkdir
$ZEDLET_DIR
3463 # Verify the ZED is not already running.
3464 pgrep
-x zed
> /dev
/null
3465 if (($?
== 0)); then
3466 log_fail
"ZED already running"
3469 log_note
"Starting ZED"
3470 # run ZED in the background and redirect foreground logging
3471 # output to $ZED_LOG.
3472 log_must truncate
-s 0 $ZED_DEBUG_LOG
3473 log_must
eval "zed -vF -d $ZEDLET_DIR -p $ZEDLET_DIR/zed.pid -P $PATH" \
3474 "-s $ZEDLET_DIR/state 2>$ZED_LOG &"
3488 log_note
"Stopping ZED"
3489 if [[ -f ${ZEDLET_DIR}/zed.pid
]]; then
3490 zedpid
=$
(cat ${ZEDLET_DIR}/zed.pid
)
3492 while ps
-p $zedpid > /dev
/null
; do
3495 rm -f ${ZEDLET_DIR}/zed.pid
3503 function zed_events_drain
3505 while [ $
(zpool events
-H |
wc -l) -ne 0 ]; do
3507 zpool events
-c >/dev
/null
3512 # Check is provided device is being active used as a swap device.
3514 function is_swap_inuse
3518 if [[ -z $device ]] ; then
3519 log_note
"No device specified."
3524 swapon
-s |
grep -w $
(readlink
-f $device) > /dev
/null
2>&1
3526 swap
-l |
grep -w $device > /dev
/null
2>&1
3533 # Setup a swap device using the provided device.
3540 log_must
eval "mkswap $swapdev > /dev/null 2>&1"
3541 log_must swapon
$swapdev
3543 log_must swap
-a $swapdev
3550 # Cleanup a swap device on the provided device.
3552 function swap_cleanup
3556 if is_swap_inuse
$swapdev; then
3558 log_must swapoff
$swapdev
3560 log_must swap
-d $swapdev
3568 # Set a global system tunable (64-bit value)
3573 function set_tunable64
3575 set_tunable_impl
"$1" "$2" Z
3579 # Set a global system tunable (32-bit value)
3584 function set_tunable32
3586 set_tunable_impl
"$1" "$2" W
3589 function set_tunable_impl
3591 typeset tunable
="$1"
3593 typeset mdb_cmd
="$3"
3594 typeset module
="${4:-zfs}"
3596 [[ -z "$tunable" ]] && return 1
3597 [[ -z "$value" ]] && return 1
3598 [[ -z "$mdb_cmd" ]] && return 1
3602 typeset zfs_tunables
="/sys/module/$module/parameters"
3603 [[ -w "$zfs_tunables/$tunable" ]] ||
return 1
3604 echo -n "$value" > "$zfs_tunables/$tunable"
3608 [[ "$module" -eq "zfs" ]] ||
return 1
3609 echo "${tunable}/${mdb_cmd}0t${value}" | mdb
-kw
3616 # Get a global system tunable
3620 function get_tunable
3622 get_tunable_impl
"$1"
3625 function get_tunable_impl
3627 typeset tunable
="$1"
3628 typeset module
="${2:-zfs}"
3630 [[ -z "$tunable" ]] && return 1
3634 typeset zfs_tunables
="/sys/module/$module/parameters"
3635 [[ -f "$zfs_tunables/$tunable" ]] ||
return 1
3636 cat $zfs_tunables/$tunable
3640 [[ "$module" -eq "zfs" ]] ||
return 1
3648 # Get actual devices used by the pool (i.e. linux sdb1 not sdb).
3650 function get_pool_devices
#testpool #devdir
3657 out
=$
(zpool status
-P $testpool |
grep ${devdir} |
awk '{print $1}')
3658 out
=$
(echo $out |
sed -e "s|${devdir}/||g" |
tr '\n' ' ')