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.
30 # Copyright (c) 2017 Open-E, Inc. All Rights Reserved.
33 .
${STF_TOOLS}/include
/logapi.shlib
34 .
${STF_SUITE}/include
/math.shlib
35 .
${STF_SUITE}/include
/blkdev.shlib
38 # Apply constrained path when available. This is required since the
39 # PATH may have been modified by sudo's secure_path behavior.
41 if [ -n "$STF_PATH" ]; then
45 # Linux kernel version comparison function
47 # $1 Linux version ("4.10", "2.6.32") or blank for installed Linux version
49 # Used for comparison: if [ $(linux_version) -ge $(linux_version "2.6.32") ]
51 function linux_version
55 [[ -z "$ver" ]] && ver
=$
(uname
-r |
grep -Eo "^[0-9]+\.[0-9]+\.[0-9]+")
57 typeset version
=$
(echo $ver | cut
-d '.' -f 1)
58 typeset major
=$
(echo $ver | cut
-d '.' -f 2)
59 typeset minor
=$
(echo $ver | cut
-d '.' -f 3)
61 [[ -z "$version" ]] && version
=0
62 [[ -z "$major" ]] && major
=0
63 [[ -z "$minor" ]] && minor
=0
65 echo $
((version
* 10000 + major
* 100 + minor
))
68 # Determine if this is a Linux test system
70 # Return 0 if platform Linux, 1 if otherwise
74 if [[ $
(uname
-o) == "GNU/Linux" ]]; then
81 # Determine if this is a 32-bit system
83 # Return 0 if platform is 32-bit, 1 if otherwise
87 if [[ $
(getconf LONG_BIT
) == "32" ]]; then
94 # Determine if kmemleak is enabled
96 # Return 0 if kmemleak is enabled, 1 if otherwise
100 if is_linux
&& [[ -e /sys
/kernel
/debug
/kmemleak
]]; then
107 # Determine whether a dataset is mounted
110 # $2 filesystem type; optional - defaulted to zfs
112 # Return 0 if dataset is mounted; 1 if unmounted; 2 on error
117 [[ -z $fstype ]] && fstype
=zfs
118 typeset out dir name ret
122 if [[ "$1" == "/"* ]] ; then
123 for out
in $
(zfs mount |
awk '{print $2}'); do
124 [[ $1 == $out ]] && return 0
127 for out
in $
(zfs mount |
awk '{print $1}'); do
128 [[ $1 == $out ]] && return 0
133 out
=$
(df
-F $fstype $1 2>/dev
/null
)
135 (($ret != 0)) && return $ret
143 [[ "$1" == "$dir" ||
"$1" == "$name" ]] && return 0
146 out
=$
(df
-t $fstype $1 2>/dev
/null
)
150 if [[ -L "$ZVOL_DEVDIR/$1" ]]; then
151 link
=$
(readlink
-f $ZVOL_DEVDIR/$1)
152 [[ -n "$link" ]] && \
153 mount |
grep -q "^$link" && \
162 # Return 0 if a dataset is mounted; 1 otherwise
165 # $2 filesystem type; optional - defaulted to zfs
170 (($?
== 0)) && return 0
174 # Return 0 if a dataset is unmounted; 1 otherwise
177 # $2 filesystem type; optional - defaulted to zfs
182 (($?
== 1)) && return 0
192 echo $1 |
sed "s/,/ /g"
195 function default_setup
197 default_setup_noexit
"$@"
203 # Given a list of disks, setup storage pools and datasets.
205 function default_setup_noexit
210 log_note begin default_setup_noexit
212 if is_global_zone
; then
213 if poolexists
$TESTPOOL ; then
214 destroy_pool
$TESTPOOL
216 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
217 log_must zpool create
-f $TESTPOOL $disklist
222 rm -rf $TESTDIR || log_unresolved Could not remove
$TESTDIR
223 mkdir
-p $TESTDIR || log_unresolved Could not create
$TESTDIR
225 log_must zfs create
$TESTPOOL/$TESTFS
226 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
228 if [[ -n $container ]]; then
229 rm -rf $TESTDIR1 || \
230 log_unresolved Could not remove
$TESTDIR1
231 mkdir
-p $TESTDIR1 || \
232 log_unresolved Could not create
$TESTDIR1
234 log_must zfs create
$TESTPOOL/$TESTCTR
235 log_must zfs
set canmount
=off
$TESTPOOL/$TESTCTR
236 log_must zfs create
$TESTPOOL/$TESTCTR/$TESTFS1
237 log_must zfs
set mountpoint
=$TESTDIR1 \
238 $TESTPOOL/$TESTCTR/$TESTFS1
241 if [[ -n $volume ]]; then
242 if is_global_zone
; then
243 log_must zfs create
-V $VOLSIZE $TESTPOOL/$TESTVOL
246 log_must zfs create
$TESTPOOL/$TESTVOL
252 # Given a list of disks, setup a storage pool, file system and
255 function default_container_setup
259 default_setup
"$disklist" "true"
263 # Given a list of disks, setup a storage pool,file system
266 function default_volume_setup
270 default_setup
"$disklist" "" "true"
274 # Given a list of disks, setup a storage pool,file system,
275 # a container and a volume.
277 function default_container_volume_setup
281 default_setup
"$disklist" "true" "true"
285 # Create a snapshot on a filesystem or volume. Defaultly create a snapshot on
288 # $1 Existing filesystem or volume name. Default, $TESTPOOL/$TESTFS
289 # $2 snapshot name. Default, $TESTSNAP
291 function create_snapshot
293 typeset fs_vol
=${1:-$TESTPOOL/$TESTFS}
294 typeset snap
=${2:-$TESTSNAP}
296 [[ -z $fs_vol ]] && log_fail
"Filesystem or volume's name is undefined."
297 [[ -z $snap ]] && log_fail
"Snapshot's name is undefined."
299 if snapexists
$fs_vol@
$snap; then
300 log_fail
"$fs_vol@$snap already exists."
302 datasetexists
$fs_vol || \
303 log_fail
"$fs_vol must exist."
305 log_must zfs snapshot
$fs_vol@
$snap
309 # Create a clone from a snapshot, default clone name is $TESTCLONE.
311 # $1 Existing snapshot, $TESTPOOL/$TESTFS@$TESTSNAP is default.
312 # $2 Clone name, $TESTPOOL/$TESTCLONE is default.
314 function create_clone
# snapshot clone
316 typeset snap
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
317 typeset clone
=${2:-$TESTPOOL/$TESTCLONE}
320 log_fail
"Snapshot name is undefined."
322 log_fail
"Clone name is undefined."
324 log_must zfs clone
$snap $clone
328 # Create a bookmark of the given snapshot. Defaultly create a bookmark on
331 # $1 Existing filesystem or volume name. Default, $TESTFS
332 # $2 Existing snapshot name. Default, $TESTSNAP
333 # $3 bookmark name. Default, $TESTBKMARK
335 function create_bookmark
337 typeset fs_vol
=${1:-$TESTFS}
338 typeset snap
=${2:-$TESTSNAP}
339 typeset bkmark
=${3:-$TESTBKMARK}
341 [[ -z $fs_vol ]] && log_fail
"Filesystem or volume's name is undefined."
342 [[ -z $snap ]] && log_fail
"Snapshot's name is undefined."
343 [[ -z $bkmark ]] && log_fail
"Bookmark's name is undefined."
345 if bkmarkexists
$fs_vol#$bkmark; then
346 log_fail
"$fs_vol#$bkmark already exists."
348 datasetexists
$fs_vol || \
349 log_fail
"$fs_vol must exist."
350 snapexists
$fs_vol@
$snap || \
351 log_fail
"$fs_vol@$snap must exist."
353 log_must zfs bookmark
$fs_vol@
$snap $fs_vol#$bkmark
357 # Create a temporary clone result of an interrupted resumable 'zfs receive'
358 # $1 Destination filesystem name. Must not exist, will be created as the result
359 # of this function along with its %recv temporary clone
360 # $2 Source filesystem name. Must not exist, will be created and destroyed
362 function create_recv_clone
365 typeset sendfs
="${2:-$TESTPOOL/create_recv_clone}"
366 typeset snap
="$sendfs@snap1"
367 typeset incr
="$sendfs@snap2"
368 typeset mountpoint
="$TESTDIR/create_recv_clone"
369 typeset sendfile
="$TESTDIR/create_recv_clone.zsnap"
371 [[ -z $recvfs ]] && log_fail
"Recv filesystem's name is undefined."
373 datasetexists
$recvfs && log_fail
"Recv filesystem must not exist."
374 datasetexists
$sendfs && log_fail
"Send filesystem must not exist."
376 log_must zfs create
-o mountpoint
="$mountpoint" $sendfs
377 log_must zfs snapshot
$snap
378 log_must
eval "zfs send $snap | zfs recv -u $recvfs"
379 log_must mkfile
1m
"$mountpoint/data"
380 log_must zfs snapshot
$incr
381 log_must
eval "zfs send -i $snap $incr | dd bs=10K count=1 > $sendfile"
382 log_mustnot
eval "zfs recv -su $recvfs < $sendfile"
383 destroy_dataset
"$sendfs" "-r"
384 log_must
rm -f "$sendfile"
386 if [[ $
(get_prop
'inconsistent' "$recvfs/%recv") -ne 1 ]]; then
387 log_fail
"Error creating temporary $recvfs/%recv clone"
391 function default_mirror_setup
393 default_mirror_setup_noexit
$1 $2 $3
399 # Given a pair of disks, set up a storage pool and dataset for the mirror
400 # @parameters: $1 the primary side of the mirror
401 # $2 the secondary side of the mirror
402 # @uses: ZPOOL ZFS TESTPOOL TESTFS
403 function default_mirror_setup_noexit
405 readonly func
="default_mirror_setup_noexit"
409 [[ -z $primary ]] && \
410 log_fail
"$func: No parameters passed"
411 [[ -z $secondary ]] && \
412 log_fail
"$func: No secondary partition passed"
413 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
414 log_must zpool create
-f $TESTPOOL mirror $@
415 log_must zfs create
$TESTPOOL/$TESTFS
416 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
420 # create a number of mirrors.
421 # We create a number($1) of 2 way mirrors using the pairs of disks named
422 # on the command line. These mirrors are *not* mounted
423 # @parameters: $1 the number of mirrors to create
424 # $... the devices to use to create the mirrors on
425 # @uses: ZPOOL ZFS TESTPOOL
426 function setup_mirrors
428 typeset
-i nmirrors
=$1
431 while ((nmirrors
> 0)); do
432 log_must
test -n "$1" -a -n "$2"
433 [[ -d /$TESTPOOL$nmirrors ]] && rm -rf /$TESTPOOL$nmirrors
434 log_must zpool create
-f $TESTPOOL$nmirrors mirror
$1 $2
436 ((nmirrors
= nmirrors
- 1))
441 # create a number of raidz pools.
442 # We create a number($1) of 2 raidz pools using the pairs of disks named
443 # on the command line. These pools are *not* mounted
444 # @parameters: $1 the number of pools to create
445 # $... the devices to use to create the pools on
446 # @uses: ZPOOL ZFS TESTPOOL
447 function setup_raidzs
449 typeset
-i nraidzs
=$1
452 while ((nraidzs
> 0)); do
453 log_must
test -n "$1" -a -n "$2"
454 [[ -d /$TESTPOOL$nraidzs ]] && rm -rf /$TESTPOOL$nraidzs
455 log_must zpool create
-f $TESTPOOL$nraidzs raidz
$1 $2
457 ((nraidzs
= nraidzs
- 1))
462 # Destroy the configured testpool mirrors.
463 # the mirrors are of the form ${TESTPOOL}{number}
464 # @uses: ZPOOL ZFS TESTPOOL
465 function destroy_mirrors
467 default_cleanup_noexit
473 # Given a minimum of two disks, set up a storage pool and dataset for the raid-z
474 # $1 the list of disks
476 function default_raidz_setup
478 typeset disklist
="$*"
479 disks
=(${disklist[*]})
481 if [[ ${#disks[*]} -lt 2 ]]; then
482 log_fail
"A raid-z requires a minimum of two disks."
485 [[ -d /$TESTPOOL ]] && rm -rf /$TESTPOOL
486 log_must zpool create
-f $TESTPOOL raidz
$disklist
487 log_must zfs create
$TESTPOOL/$TESTFS
488 log_must zfs
set mountpoint
=$TESTDIR $TESTPOOL/$TESTFS
494 # Common function used to cleanup storage pools and datasets.
496 # Invoked at the start of the test suite to ensure the system
497 # is in a known state, and also at the end of each set of
498 # sub-tests to ensure errors from one set of tests doesn't
499 # impact the execution of the next set.
501 function default_cleanup
503 default_cleanup_noexit
509 # Utility function used to list all available pool names.
511 # NOTE: $KEEP is a variable containing pool names, separated by a newline
512 # character, that must be excluded from the returned list.
514 function get_all_pools
516 zpool list
-H -o name |
grep -Fvx "$KEEP" |
grep -v "$NO_POOLS"
519 function default_cleanup_noexit
523 # Destroying the pool will also destroy any
524 # filesystems it contains.
526 if is_global_zone
; then
527 zfs unmount
-a > /dev
/null
2>&1
528 ALL_POOLS
=$
(get_all_pools
)
529 # Here, we loop through the pools we're allowed to
530 # destroy, only destroying them if it's safe to do
532 while [ ! -z ${ALL_POOLS} ]
534 for pool
in ${ALL_POOLS}
536 if safe_to_destroy_pool
$pool ;
540 ALL_POOLS
=$
(get_all_pools
)
547 for fs
in $
(zfs list
-H -o name \
548 |
grep "^$ZONE_POOL/$ZONE_CTR[01234]/"); do
549 destroy_dataset
"$fs" "-Rf"
552 # Need cleanup here to avoid garbage dir left.
553 for fs
in $
(zfs list
-H -o name
); do
554 [[ $fs == /$ZONE_POOL ]] && continue
555 [[ -d $fs ]] && log_must
rm -rf $fs/*
559 # Reset the $ZONE_POOL/$ZONE_CTR[01234] file systems property to
562 for fs
in $
(zfs list
-H -o name
); do
563 if [[ $fs == $ZONE_POOL/$ZONE_CTR[01234] ]]; then
564 log_must zfs
set reservation
=none
$fs
565 log_must zfs
set recordsize
=128K
$fs
566 log_must zfs
set mountpoint
=/$fs $fs
568 enc
=$
(get_prop encryption
$fs)
569 if [[ $?
-ne 0 ]] ||
[[ -z "$enc" ]] || \
570 [[ "$enc" == "off" ]]; then
571 log_must zfs
set checksum
=on
$fs
573 log_must zfs
set compression
=off
$fs
574 log_must zfs
set atime
=on
$fs
575 log_must zfs
set devices
=off
$fs
576 log_must zfs
set exec=on
$fs
577 log_must zfs
set setuid
=on
$fs
578 log_must zfs
set readonly=off
$fs
579 log_must zfs
set snapdir
=hidden
$fs
580 log_must zfs
set aclmode
=groupmask
$fs
581 log_must zfs
set aclinherit
=secure
$fs
586 [[ -d $TESTDIR ]] && \
587 log_must
rm -rf $TESTDIR
590 if is_mpath_device
$disk1; then
597 # Common function used to cleanup storage pools, file systems
600 function default_container_cleanup
602 if ! is_global_zone
; then
606 ismounted
$TESTPOOL/$TESTCTR/$TESTFS1
608 log_must zfs unmount
$TESTPOOL/$TESTCTR/$TESTFS1
610 destroy_dataset
"$TESTPOOL/$TESTCTR/$TESTFS1" "-R"
611 destroy_dataset
"$TESTPOOL/$TESTCTR" "-Rf"
613 [[ -e $TESTDIR1 ]] && \
614 log_must
rm -rf $TESTDIR1 > /dev
/null
2>&1
620 # Common function used to cleanup snapshot of file system or volume. Default to
621 # delete the file system's snapshot
625 function destroy_snapshot
627 typeset snap
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
629 if ! snapexists
$snap; then
630 log_fail
"'$snap' does not existed."
634 # For the sake of the value which come from 'get_prop' is not equal
635 # to the really mountpoint when the snapshot is unmounted. So, firstly
636 # check and make sure this snapshot's been mounted in current system.
639 if ismounted
$snap; then
640 mtpt
=$
(get_prop mountpoint
$snap)
642 log_fail
"get_prop mountpoint $snap failed."
645 destroy_dataset
"$snap"
646 [[ $mtpt != "" && -d $mtpt ]] && \
647 log_must
rm -rf $mtpt
651 # Common function used to cleanup clone.
655 function destroy_clone
657 typeset clone
=${1:-$TESTPOOL/$TESTCLONE}
659 if ! datasetexists
$clone; then
660 log_fail
"'$clone' does not existed."
663 # With the same reason in destroy_snapshot
665 if ismounted
$clone; then
666 mtpt
=$
(get_prop mountpoint
$clone)
668 log_fail
"get_prop mountpoint $clone failed."
671 destroy_dataset
"$clone"
672 [[ $mtpt != "" && -d $mtpt ]] && \
673 log_must
rm -rf $mtpt
677 # Common function used to cleanup bookmark of file system or volume. Default
678 # to delete the file system's bookmark.
682 function destroy_bookmark
684 typeset bkmark
=${1:-$TESTPOOL/$TESTFS#$TESTBKMARK}
686 if ! bkmarkexists
$bkmark; then
687 log_fail
"'$bkmarkp' does not existed."
690 destroy_dataset
"$bkmark"
693 # Return 0 if a snapshot exists; $? otherwise
699 zfs list
-H -t snapshot
"$1" > /dev
/null
2>&1
704 # Return 0 if a bookmark exists; $? otherwise
708 function bkmarkexists
710 zfs list
-H -t bookmark
"$1" > /dev
/null
2>&1
715 # Set a property to a certain value on a dataset.
716 # Sets a property of the dataset to the value as passed in.
718 # $1 dataset who's property is being set
720 # $3 value to set property to
722 # 0 if the property could be set.
723 # non-zero otherwise.
726 function dataset_setprop
728 typeset fn
=dataset_setprop
731 log_note
"$fn: Insufficient parameters (need 3, had $#)"
735 output
=$
(zfs
set $2=$3 $1 2>&1)
738 log_note
"Setting property on $1 failed."
739 log_note
"property $2=$3"
740 log_note
"Return Code: $rv"
741 log_note
"Output: $output"
748 # Assign suite defined dataset properties.
749 # This function is used to apply the suite's defined default set of
750 # properties to a dataset.
751 # @parameters: $1 dataset to use
752 # @uses: ZFS COMPRESSION_PROP CHECKSUM_PROP
754 # 0 if the dataset has been altered.
755 # 1 if no pool name was passed in.
756 # 2 if the dataset could not be found.
757 # 3 if the dataset could not have it's properties set.
759 function dataset_set_defaultproperties
763 [[ -z $dataset ]] && return 1
767 for confset
in $
(zfs list
); do
768 if [[ $dataset = $confset ]]; then
773 [[ $found -eq 0 ]] && return 2
774 if [[ -n $COMPRESSION_PROP ]]; then
775 dataset_setprop
$dataset compression
$COMPRESSION_PROP || \
777 log_note
"Compression set to '$COMPRESSION_PROP' on $dataset"
779 if [[ -n $CHECKSUM_PROP ]]; then
780 dataset_setprop
$dataset checksum
$CHECKSUM_PROP || \
782 log_note
"Checksum set to '$CHECKSUM_PROP' on $dataset"
788 # Check a numeric assertion
789 # @parameter: $@ the assertion to check
790 # @output: big loud notice if assertion failed
795 (($@
)) || log_fail
"$@"
799 # Function to format partition size of a disk
800 # Given a disk cxtxdx reduces all partitions
803 function zero_partitions
#<whole_disk_name>
809 DSK
=$DEV_DSKDIR/$diskname
810 DSK
=$
(echo $DSK |
sed -e "s|//|/|g")
811 log_must parted
$DSK -s -- mklabel gpt
812 blockdev
--rereadpt $DSK 2>/dev
/null
815 for i
in 0 1 3 4 5 6 7
817 log_must set_partition
$i "" 0mb
$diskname
825 # Given a slice, size and disk, this function
826 # formats the slice to the specified size.
827 # Size should be specified with units as per
828 # the `format` command requirements eg. 100mb 3gb
830 # NOTE: This entire interface is problematic for the Linux parted utilty
831 # which requires the end of the partition to be specified. It would be
832 # best to retire this interface and replace it with something more flexible.
833 # At the moment a best effort is made.
835 function set_partition
#<slice_num> <slice_start> <size_plus_units> <whole_disk_name>
837 typeset
-i slicenum
=$1
843 if [[ -z $size ||
-z $disk ]]; then
844 log_fail
"The size or disk name is unspecified."
846 typeset size_mb
=${size%%[mMgG]}
848 size_mb
=${size_mb%%[mMgG][bB]}
849 if [[ ${size:1:1} == 'g' ]]; then
850 ((size_mb
= size_mb
* 1024))
853 # Create GPT partition table when setting slice 0 or
854 # when the device doesn't already contain a GPT label.
855 parted
$DEV_DSKDIR/$disk -s -- print
1 >/dev
/null
857 if [[ $slicenum -eq 0 ||
$ret_val -ne 0 ]]; then
858 parted
$DEV_DSKDIR/$disk -s -- mklabel gpt
859 if [[ $?
-ne 0 ]]; then
860 log_note
"Failed to create GPT partition table on $disk"
865 # When no start is given align on the first cylinder.
866 if [[ -z "$start" ]]; then
870 # Determine the cylinder size for the device and using
871 # that calculate the end offset in cylinders.
872 typeset
-i cly_size_kb
=0
873 cly_size_kb
=$
(parted
-m $DEV_DSKDIR/$disk -s -- \
874 unit cyl print |
head -3 |
tail -1 | \
875 awk -F '[:k.]' '{print $4}')
876 ((end
= (size_mb
* 1024 / cly_size_kb
) + start
))
878 parted
$DEV_DSKDIR/$disk -s -- \
879 mkpart part
$slicenum ${start}cyl
${end}cyl
880 if [[ $?
-ne 0 ]]; then
881 log_note
"Failed to create partition $slicenum on $disk"
885 blockdev
--rereadpt $DEV_DSKDIR/$disk 2>/dev
/null
888 if [[ -z $slicenum ||
-z $size ||
-z $disk ]]; then
889 log_fail
"The slice, size or disk name is unspecified."
892 typeset format_file
=/var
/tmp
/format_in.$$
894 echo "partition" >$format_file
895 echo "$slicenum" >> $format_file
896 echo "" >> $format_file
897 echo "" >> $format_file
898 echo "$start" >> $format_file
899 echo "$size" >> $format_file
900 echo "label" >> $format_file
901 echo "" >> $format_file
902 echo "q" >> $format_file
903 echo "q" >> $format_file
905 format
-e -s -d $disk -f $format_file
910 if [[ $ret_val -ne 0 ]]; then
911 log_note
"Unable to format $disk slice $slicenum to $size"
918 # Delete all partitions on all disks - this is specifically for the use of multipath
919 # devices which currently can only be used in the test suite as raw/un-partitioned
920 # devices (ie a zpool cannot be created on a whole mpath device that has partitions)
922 function delete_partitions
926 if [[ -z $DISK_ARRAY_NUM ]]; then
927 DISK_ARRAY_NUM
=$
(echo ${DISKS} | nawk
'{print NF}')
929 if [[ -z $DISKSARRAY ]]; then
934 if (( $DISK_ARRAY_NUM == 1 )); then
935 while ((j
< MAX_PARTITIONS
)); do
936 parted
$DEV_DSKDIR/$DISK -s rm $j \
938 if (( $?
== 1 )); then
939 lsblk |
egrep ${DISK}${SLICE_PREFIX}${j} > /dev
/null
940 if (( $?
== 1 )); then
941 log_note
"Partitions for $DISK should be deleted"
943 log_fail
"Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
947 lsblk |
egrep ${DISK}${SLICE_PREFIX}${j} > /dev
/null
948 if (( $?
== 0 )); then
949 log_fail
"Partition for ${DISK}${SLICE_PREFIX}${j} not deleted"
955 for disk
in `echo $DISKSARRAY`; do
956 while ((j
< MAX_PARTITIONS
)); do
957 parted
$DEV_DSKDIR/$disk -s rm $j > /dev
/null
2>&1
958 if (( $?
== 1 )); then
959 lsblk |
egrep ${disk}${SLICE_PREFIX}${j} > /dev
/null
960 if (( $?
== 1 )); then
961 log_note
"Partitions for $disk should be deleted"
963 log_fail
"Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
967 lsblk |
egrep ${disk}${SLICE_PREFIX}${j} > /dev
/null
968 if (( $?
== 0 )); then
969 log_fail
"Partition for ${disk}${SLICE_PREFIX}${j} not deleted"
982 # Get the end cyl of the given slice
984 function get_endslice
#<disk> <slice>
988 if [[ -z $disk ||
-z $slice ]] ; then
989 log_fail
"The disk name or slice number is unspecified."
993 endcyl
=$
(parted
-s $DEV_DSKDIR/$disk -- unit cyl print | \
994 grep "part${slice}" | \
997 ((endcyl
= (endcyl
+ 1)))
999 disk
=${disk#/dev/dsk/}
1000 disk
=${disk#/dev/rdsk/}
1004 ratio
=$
(prtvtoc
/dev
/rdsk
/${disk}s2 | \
1005 grep "sectors\/cylinder" | \
1008 if ((ratio
== 0)); then
1012 typeset
-i endcyl
=$
(prtvtoc
-h /dev
/rdsk
/${disk}s2 |
1013 nawk
-v token
="$slice" '{if ($1==token) print $6}')
1015 ((endcyl
= (endcyl
+ 1) / ratio
))
1023 # Given a size,disk and total slice number, this function formats the
1024 # disk slices from 0 to the total slice number with the same specified
1027 function partition_disk
#<slice_size> <whole_disk_name> <total_slices>
1030 typeset slice_size
=$1
1031 typeset disk_name
=$2
1032 typeset total_slices
=$3
1035 zero_partitions
$disk_name
1036 while ((i
< $total_slices)); do
1043 log_must set_partition
$i "$cyl" $slice_size $disk_name
1044 cyl
=$
(get_endslice
$disk_name $i)
1050 # This function continues to write to a filenum number of files into dirnum
1051 # number of directories until either file_write returns an error or the
1052 # maximum number of files per directory have been written.
1055 # fill_fs [destdir] [dirnum] [filenum] [bytes] [num_writes] [data]
1057 # Return value: 0 on success
1061 # destdir: is the directory where everything is to be created under
1062 # dirnum: the maximum number of subdirectories to use, -1 no limit
1063 # filenum: the maximum number of files per subdirectory
1064 # bytes: number of bytes to write
1065 # num_writes: numer of types to write out bytes
1066 # data: the data that will be written
1069 # file_fs /testdir 20 25 1024 256 0
1071 # Note: bytes * num_writes equals the size of the testfile
1073 function fill_fs
# destdir dirnum filenum bytes num_writes data
1075 typeset destdir
=${1:-$TESTDIR}
1076 typeset
-i dirnum
=${2:-50}
1077 typeset
-i filenum
=${3:-50}
1078 typeset
-i bytes
=${4:-8192}
1079 typeset
-i num_writes
=${5:-10240}
1080 typeset
-i data
=${6:-0}
1082 typeset
-i odirnum
=1
1083 typeset
-i idirnum
=0
1087 log_must mkdir
-p $destdir/$idirnum
1088 while (($odirnum > 0)); do
1089 if ((dirnum
>= 0 && idirnum
>= dirnum
)); then
1093 file_write
-o create
-f $destdir/$idirnum/$TESTFILE.
$fn \
1094 -b $bytes -c $num_writes -d $data
1096 if (($retval != 0)); then
1100 if (($fn >= $filenum)); then
1102 ((idirnum
= idirnum
+ 1))
1103 log_must mkdir
-p $destdir/$idirnum
1112 # Simple function to get the specified property. If unable to
1113 # get the property then exits.
1115 # Note property is in 'parsable' format (-p)
1117 function get_prop
# property dataset
1123 prop_val
=$
(zfs get
-pH -o value
$prop $dataset 2>/dev
/null
)
1124 if [[ $?
-ne 0 ]]; then
1125 log_note
"Unable to get $prop property for dataset " \
1135 # Simple function to get the specified property of pool. If unable to
1136 # get the property then exits.
1138 # Note property is in 'parsable' format (-p)
1140 function get_pool_prop
# property pool
1146 if poolexists
$pool ; then
1147 prop_val
=$
(zpool get
-pH $prop $pool 2>/dev
/null |
tail -1 | \
1149 if [[ $?
-ne 0 ]]; then
1150 log_note
"Unable to get $prop property for pool " \
1155 log_note
"Pool $pool not exists."
1163 # Return 0 if a pool exists; $? otherwise
1171 if [[ -z $pool ]]; then
1172 log_note
"No pool name given."
1176 zpool get name
"$pool" > /dev
/null
2>&1
1180 # Return 0 if all the specified datasets exist; $? otherwise
1183 function datasetexists
1185 if (($# == 0)); then
1186 log_note
"No dataset name given."
1190 while (($# > 0)); do
1191 zfs get name
$1 > /dev
/null
2>&1 || \
1199 # return 0 if none of the specified datasets exists, otherwise return 1.
1202 function datasetnonexists
1204 if (($# == 0)); then
1205 log_note
"No dataset name given."
1209 while (($# > 0)); do
1210 zfs list
-H -t filesystem
,snapshot
,volume
$1 > /dev
/null
2>&1 \
1219 # Given a mountpoint, or a dataset name, determine if it is shared via NFS.
1221 # Returns 0 if shared, 1 otherwise.
1228 if [[ $fs != "/"* ]] ; then
1229 if datasetnonexists
"$fs" ; then
1232 mtpt
=$
(get_prop mountpoint
"$fs")
1234 none|legacy|
-) return 1
1243 for mtpt
in `share | awk '{print $1}'` ; do
1244 if [[ $mtpt == $fs ]] ; then
1251 for mtpt
in `share | awk '{print $2}'` ; do
1252 if [[ $mtpt == $fs ]] ; then
1257 typeset stat
=$
(svcs
-H -o STA nfs
/server
:default
)
1258 if [[ $stat != "ON" ]]; then
1259 log_note
"Current nfs/server status: $stat"
1266 # Given a dataset name determine if it is shared via SMB.
1268 # Returns 0 if shared, 1 otherwise.
1270 function is_shared_smb
1275 if datasetnonexists
"$fs" ; then
1278 fs
=$
(echo $fs |
sed 's@/@_@g')
1282 for mtpt
in `net usershare list | awk '{print $1}'` ; do
1283 if [[ $mtpt == $fs ]] ; then
1289 log_unsupported
"Currently unsupported by the test framework"
1295 # Given a mountpoint, determine if it is not shared via NFS.
1297 # Returns 0 if not shared, 1 otherwise.
1304 if (($?
== 0)); then
1312 # Given a dataset determine if it is not shared via SMB.
1314 # Returns 0 if not shared, 1 otherwise.
1316 function not_shared_smb
1321 if (($?
== 0)); then
1329 # Helper function to unshare a mountpoint.
1331 function unshare_fs
#fs
1335 is_shared
$fs || is_shared_smb
$fs
1336 if (($?
== 0)); then
1337 log_must zfs unshare
$fs
1344 # Helper function to share a NFS mountpoint.
1346 function share_nfs
#fs
1352 if (($?
!= 0)); then
1353 log_must share
"*:$fs"
1357 if (($?
!= 0)); then
1358 log_must share
-F nfs
$fs
1366 # Helper function to unshare a NFS mountpoint.
1368 function unshare_nfs
#fs
1374 if (($?
== 0)); then
1375 log_must unshare
-u "*:$fs"
1379 if (($?
== 0)); then
1380 log_must unshare
-F nfs
$fs
1388 # Helper function to show NFS shares.
1390 function showshares_nfs
1402 # Helper function to show SMB shares.
1404 function showshares_smb
1416 # Check NFS server status and trigger it online.
1418 function setup_nfs_server
1420 # Cannot share directory in non-global zone.
1422 if ! is_global_zone
; then
1423 log_note
"Cannot trigger NFS server by sharing in LZ."
1429 # Re-synchronize /var/lib/nfs/etab with /etc/exports and
1430 # /etc/exports.d./* to provide a clean test environment.
1434 log_note
"NFS server must be started prior to running ZTS."
1438 typeset nfs_fmri
="svc:/network/nfs/server:default"
1439 if [[ $
(svcs
-Ho STA
$nfs_fmri) != "ON" ]]; then
1441 # Only really sharing operation can enable NFS server
1442 # to online permanently.
1444 typeset dummy
=/tmp
/dummy
1446 if [[ -d $dummy ]]; then
1447 log_must
rm -rf $dummy
1450 log_must mkdir
$dummy
1451 log_must share
$dummy
1454 # Waiting for fmri's status to be the final status.
1455 # Otherwise, in transition, an asterisk (*) is appended for
1456 # instances, unshare will reverse status to 'DIS' again.
1458 # Waiting for 1's at least.
1462 while [[ timeout
-ne 0 && $
(svcs
-Ho STA
$nfs_fmri) == *'*' ]]
1469 log_must unshare
$dummy
1470 log_must
rm -rf $dummy
1473 log_note
"Current NFS status: '$(svcs -Ho STA,FMRI $nfs_fmri)'"
1477 # To verify whether calling process is in global zone
1479 # Return 0 if in global zone, 1 in non-global zone
1481 function is_global_zone
1486 typeset cur_zone
=$
(zonename
2>/dev
/null
)
1487 if [[ $cur_zone != "global" ]]; then
1495 # Verify whether test is permitted to run from
1496 # global zone, local zone, or both
1498 # $1 zone limit, could be "global", "local", or "both"(no limit)
1500 # Return 0 if permitted, otherwise exit with log_unsupported
1502 function verify_runnable
# zone limit
1506 [[ -z $limit ]] && return 0
1508 if is_global_zone
; then
1512 local) log_unsupported
"Test is unable to run from "\
1515 *) log_note
"Warning: unknown limit $limit - " \
1523 global
) log_unsupported
"Test is unable to run from "\
1526 *) log_note
"Warning: unknown limit $limit - " \
1537 # Return 0 if create successfully or the pool exists; $? otherwise
1538 # Note: In local zones, this function should return 0 silently.
1541 # $2-n - [keyword] devs_list
1543 function create_pool
#pool devs_list
1545 typeset pool
=${1%%/*}
1549 if [[ -z $pool ]]; then
1550 log_note
"Missing pool name."
1554 if poolexists
$pool ; then
1558 if is_global_zone
; then
1559 [[ -d /$pool ]] && rm -rf /$pool
1560 log_must zpool create
-f $pool $@
1566 # Return 0 if destroy successfully or the pool exists; $? otherwise
1567 # Note: In local zones, this function should return 0 silently.
1570 # Destroy pool with the given parameters.
1572 function destroy_pool
#pool
1574 typeset pool
=${1%%/*}
1577 if [[ -z $pool ]]; then
1578 log_note
"No pool name given."
1582 if is_global_zone
; then
1583 if poolexists
"$pool" ; then
1584 mtpt
=$
(get_prop mountpoint
"$pool")
1586 # At times, syseventd/udev activity can cause attempts
1587 # to destroy a pool to fail with EBUSY. We retry a few
1588 # times allowing failures before requiring the destroy
1590 log_must_busy zpool destroy
-f $pool
1593 log_must
rm -rf $mtpt
1595 log_note
"Pool does not exist. ($pool)"
1603 # Return 0 if destroy successfully or the dataset exists; $? otherwise
1604 # Note: In local zones, this function should return 0 silently.
1607 # $2 - custom arguments for zfs destroy
1608 # Destroy dataset with the given parameters.
1610 function destroy_dataset
#dataset #args
1614 typeset args
=${2:-""}
1616 if [[ -z $dataset ]]; then
1617 log_note
"No dataset name given."
1621 if is_global_zone
; then
1622 if datasetexists
"$dataset" ; then
1623 mtpt
=$
(get_prop mountpoint
"$dataset")
1624 log_must_busy zfs destroy
$args $dataset
1627 log_must
rm -rf $mtpt
1629 log_note
"Dataset does not exist. ($dataset)"
1638 # Firstly, create a pool with 5 datasets. Then, create a single zone and
1639 # export the 5 datasets to it. In addition, we also add a ZFS filesystem
1640 # and a zvol device to the zone.
1643 # $2 zone root directory prefix
1646 function zfs_zones_setup
#zone_name zone_root zone_ip
1648 typeset zone_name
=${1:-$(hostname)-z}
1649 typeset zone_root
=${2:-"/zone_root"}
1650 typeset zone_ip
=${3:-"10.1.1.10"}
1651 typeset prefix_ctr
=$ZONE_CTR
1652 typeset pool_name
=$ZONE_POOL
1656 # Create pool and 5 container within it
1658 [[ -d /$pool_name ]] && rm -rf /$pool_name
1659 log_must zpool create
-f $pool_name $DISKS
1660 while ((i
< cntctr
)); do
1661 log_must zfs create
$pool_name/$prefix_ctr$i
1666 log_must zfs create
-V 1g
$pool_name/zone_zvol
1670 # If current system support slog, add slog device for pool
1672 if verify_slog_support
; then
1673 typeset sdevs
="$TEST_BASE_DIR/sdev1 $TEST_BASE_DIR/sdev2"
1674 log_must mkfile
$MINVDEVSIZE $sdevs
1675 log_must zpool add
$pool_name log mirror
$sdevs
1678 # this isn't supported just yet.
1679 # Create a filesystem. In order to add this to
1680 # the zone, it must have it's mountpoint set to 'legacy'
1681 # log_must zfs create $pool_name/zfs_filesystem
1682 # log_must zfs set mountpoint=legacy $pool_name/zfs_filesystem
1684 [[ -d $zone_root ]] && \
1685 log_must
rm -rf $zone_root/$zone_name
1686 [[ ! -d $zone_root ]] && \
1687 log_must mkdir
-p -m 0700 $zone_root/$zone_name
1689 # Create zone configure file and configure the zone
1691 typeset zone_conf
=/tmp
/zone_conf.$$
1692 echo "create" > $zone_conf
1693 echo "set zonepath=$zone_root/$zone_name" >> $zone_conf
1694 echo "set autoboot=true" >> $zone_conf
1696 while ((i
< cntctr
)); do
1697 echo "add dataset" >> $zone_conf
1698 echo "set name=$pool_name/$prefix_ctr$i" >> \
1700 echo "end" >> $zone_conf
1704 # add our zvol to the zone
1705 echo "add device" >> $zone_conf
1706 echo "set match=/dev/zvol/dsk/$pool_name/zone_zvol" >> $zone_conf
1707 echo "end" >> $zone_conf
1709 # add a corresponding zvol rdsk to the zone
1710 echo "add device" >> $zone_conf
1711 echo "set match=$ZVOL_RDEVDIR/$pool_name/zone_zvol" >> $zone_conf
1712 echo "end" >> $zone_conf
1714 # once it's supported, we'll add our filesystem to the zone
1715 # echo "add fs" >> $zone_conf
1716 # echo "set type=zfs" >> $zone_conf
1717 # echo "set special=$pool_name/zfs_filesystem" >> $zone_conf
1718 # echo "set dir=/export/zfs_filesystem" >> $zone_conf
1719 # echo "end" >> $zone_conf
1721 echo "verify" >> $zone_conf
1722 echo "commit" >> $zone_conf
1723 log_must zonecfg
-z $zone_name -f $zone_conf
1724 log_must
rm -f $zone_conf
1727 zoneadm
-z $zone_name install
1728 if (($?
== 0)); then
1729 log_note
"SUCCESS: zoneadm -z $zone_name install"
1731 log_fail
"FAIL: zoneadm -z $zone_name install"
1734 # Install sysidcfg file
1736 typeset sysidcfg
=$zone_root/$zone_name/root
/etc
/sysidcfg
1737 echo "system_locale=C" > $sysidcfg
1738 echo "terminal=dtterm" >> $sysidcfg
1739 echo "network_interface=primary {" >> $sysidcfg
1740 echo "hostname=$zone_name" >> $sysidcfg
1741 echo "}" >> $sysidcfg
1742 echo "name_service=NONE" >> $sysidcfg
1743 echo "root_password=mo791xfZ/SFiw" >> $sysidcfg
1744 echo "security_policy=NONE" >> $sysidcfg
1745 echo "timezone=US/Eastern" >> $sysidcfg
1748 log_must zoneadm
-z $zone_name boot
1752 # Reexport TESTPOOL & TESTPOOL(1-4)
1754 function reexport_pool
1759 while ((i
< cntctr
)); do
1761 TESTPOOL
=$ZONE_POOL/$ZONE_CTR$i
1762 if ! ismounted
$TESTPOOL; then
1763 log_must zfs mount
$TESTPOOL
1766 eval TESTPOOL
$i=$ZONE_POOL/$ZONE_CTR$i
1767 if eval ! ismounted \
$TESTPOOL$i; then
1768 log_must
eval zfs mount \
$TESTPOOL$i
1776 # Verify a given disk or pool state
1778 # Return 0 is pool/disk matches expected state, 1 otherwise
1780 function check_state
# pool disk state{online,offline,degraded}
1783 typeset disk
=${2#$DEV_DSKDIR/}
1786 [[ -z $pool ]] ||
[[ -z $state ]] \
1787 && log_fail
"Arguments invalid or missing"
1789 if [[ -z $disk ]]; then
1790 #check pool state only
1791 zpool get
-H -o value health
$pool \
1792 |
grep -i "$state" > /dev
/null
2>&1
1794 zpool status
-v $pool |
grep "$disk" \
1795 |
grep -i "$state" > /dev
/null
2>&1
1802 # Get the mountpoint of snapshot
1803 # For the snapshot use <mp_filesystem>/.zfs/snapshot/<snap>
1806 function snapshot_mountpoint
1808 typeset dataset
=${1:-$TESTPOOL/$TESTFS@$TESTSNAP}
1810 if [[ $dataset != *@
* ]]; then
1811 log_fail
"Error name of snapshot '$dataset'."
1814 typeset fs
=${dataset%@*}
1815 typeset snap
=${dataset#*@}
1817 if [[ -z $fs ||
-z $snap ]]; then
1818 log_fail
"Error name of snapshot '$dataset'."
1821 echo $
(get_prop mountpoint
$fs)/.zfs
/snapshot
/$snap
1825 # Given a device and 'ashift' value verify it's correctly set on every label
1827 function verify_ashift
# device ashift
1832 zdb
-e -lll $device |
awk -v ashift
=$ashift '/ashift: / {
1848 # Given a pool and file system, this function will verify the file system
1849 # using the zdb internal tool. Note that the pool is exported and imported
1850 # to ensure it has consistent state.
1852 function verify_filesys
# pool filesystem dir
1855 typeset filesys
="$2"
1856 typeset zdbout
="/tmp/zdbout.$$"
1861 typeset search_path
=""
1863 log_note
"Calling zdb to verify filesystem '$filesys'"
1864 zfs unmount
-a > /dev
/null
2>&1
1865 log_must zpool
export $pool
1867 if [[ -n $dirs ]] ; then
1868 for dir
in $dirs ; do
1869 search_path
="$search_path -d $dir"
1873 log_must zpool import
$search_path $pool
1875 zdb
-cudi $filesys > $zdbout 2>&1
1876 if [[ $?
!= 0 ]]; then
1877 log_note
"Output: zdb -cudi $filesys"
1879 log_fail
"zdb detected errors with: '$filesys'"
1882 log_must zfs mount
-a
1883 log_must
rm -rf $zdbout
1887 # Given a pool, and this function list all disks in the pool
1889 function get_disklist
# pool
1893 disklist
=$
(zpool iostat
-v $1 | nawk
'(NR >4) {print $1}' | \
1894 grep -v "\-\-\-\-\-" | \
1895 egrep -v -e "^(mirror|raidz1|raidz2|spare|log|cache)$")
1901 # Given a pool, and this function list all disks in the pool with their full
1902 # path (like "/dev/sda" instead of "sda").
1904 function get_disklist_fullpath
# pool
1913 # This function kills a given list of processes after a time period. We use
1914 # this in the stress tests instead of STF_TIMEOUT so that we can have processes
1915 # run for a fixed amount of time, yet still pass. Tests that hit STF_TIMEOUT
1916 # would be listed as FAIL, which we don't want : we're happy with stress tests
1917 # running for a certain amount of time, then finishing.
1919 # @param $1 the time in seconds after which we should terminate these processes
1920 # @param $2..$n the processes we wish to terminate.
1922 function stress_timeout
1924 typeset
-i TIMEOUT
=$1
1928 log_note
"Waiting for child processes($cpids). " \
1929 "It could last dozens of minutes, please be patient ..."
1930 log_must
sleep $TIMEOUT
1932 log_note
"Killing child processes after ${TIMEOUT} stress timeout."
1934 for pid
in $cpids; do
1935 ps
-p $pid > /dev
/null
2>&1
1936 if (($?
== 0)); then
1937 log_must
kill -USR1 $pid
1943 # Verify a given hotspare disk is inuse or avail
1945 # Return 0 is pool/disk matches expected state, 1 otherwise
1947 function check_hotspare_state
# pool disk state{inuse,avail}
1950 typeset disk
=${2#$DEV_DSKDIR/}
1953 cur_state
=$
(get_device_state
$pool $disk "spares")
1955 if [[ $state != ${cur_state} ]]; then
1962 # Wait until a hotspare transitions to a given state or times out.
1964 # Return 0 when pool/disk matches expected state, 1 on timeout.
1966 function wait_hotspare_state
# pool disk state timeout
1969 typeset disk
=${2#$/DEV_DSKDIR/}
1971 typeset timeout
=${4:-60}
1974 while [[ $i -lt $timeout ]]; do
1975 if check_hotspare_state
$pool $disk $state; then
1987 # Verify a given slog disk is inuse or avail
1989 # Return 0 is pool/disk matches expected state, 1 otherwise
1991 function check_slog_state
# pool disk state{online,offline,unavail}
1994 typeset disk
=${2#$DEV_DSKDIR/}
1997 cur_state
=$
(get_device_state
$pool $disk "logs")
1999 if [[ $state != ${cur_state} ]]; then
2006 # Verify a given vdev disk is inuse or avail
2008 # Return 0 is pool/disk matches expected state, 1 otherwise
2010 function check_vdev_state
# pool disk state{online,offline,unavail}
2013 typeset disk
=${2#$/DEV_DSKDIR/}
2016 cur_state
=$
(get_device_state
$pool $disk)
2018 if [[ $state != ${cur_state} ]]; then
2025 # Wait until a vdev transitions to a given state or times out.
2027 # Return 0 when pool/disk matches expected state, 1 on timeout.
2029 function wait_vdev_state
# pool disk state timeout
2032 typeset disk
=${2#$/DEV_DSKDIR/}
2034 typeset timeout
=${4:-60}
2037 while [[ $i -lt $timeout ]]; do
2038 if check_vdev_state
$pool $disk $state; then
2050 # Check the output of 'zpool status -v <pool>',
2051 # and to see if the content of <token> contain the <keyword> specified.
2053 # Return 0 is contain, 1 otherwise
2055 function check_pool_status
# pool token keyword <verbose>
2060 typeset verbose
=${4:-false}
2062 scan
=$
(zpool status
-v "$pool" 2>/dev
/null | nawk
-v token
="$token:" '
2063 ($1==token) {print $0}')
2064 if [[ $verbose == true
]]; then
2067 echo $scan |
grep -i "$keyword" > /dev
/null
2>&1
2073 # These 6 following functions are instance of check_pool_status()
2074 # is_pool_resilvering - to check if the pool is resilver in progress
2075 # is_pool_resilvered - to check if the pool is resilver completed
2076 # is_pool_scrubbing - to check if the pool is scrub in progress
2077 # is_pool_scrubbed - to check if the pool is scrub completed
2078 # is_pool_scrub_stopped - to check if the pool is scrub stopped
2079 # is_pool_scrub_paused - to check if the pool has scrub paused
2081 function is_pool_resilvering
#pool <verbose>
2083 check_pool_status
"$1" "scan" "resilver in progress since " $2
2087 function is_pool_resilvered
#pool <verbose>
2089 check_pool_status
"$1" "scan" "resilvered " $2
2093 function is_pool_scrubbing
#pool <verbose>
2095 check_pool_status
"$1" "scan" "scrub in progress since " $2
2099 function is_pool_scrubbed
#pool <verbose>
2101 check_pool_status
"$1" "scan" "scrub repaired" $2
2105 function is_pool_scrub_stopped
#pool <verbose>
2107 check_pool_status
"$1" "scan" "scrub canceled" $2
2111 function is_pool_scrub_paused
#pool <verbose>
2113 check_pool_status
"$1" "scan" "scrub paused since " $2
2118 # Use create_pool()/destroy_pool() to clean up the information in
2119 # in the given disk to avoid slice overlapping.
2121 function cleanup_devices
#vdevs
2123 typeset pool
="foopool$$"
2125 if poolexists
$pool ; then
2129 create_pool
$pool $@
2136 # A function to find and locate free disks on a system or from given
2137 # disks as the parameter. It works by locating disks that are in use
2138 # as swap devices and dump devices, and also disks listed in /etc/vfstab
2140 # $@ given disks to find which are free, default is all disks in
2143 # @return a string containing the list of available disks
2147 # Trust provided list, no attempt is made to locate unused devices.
2154 sfi
=/tmp
/swaplist.$$
2155 dmpi
=/tmp
/dumpdev.$$
2156 max_finddisksnum
=${MAX_FINDDISKSNUM:-6}
2159 dumpadm
> $dmpi 2>/dev
/null
2161 # write an awk script that can process the output of format
2162 # to produce a list of disks we know about. Note that we have
2163 # to escape "$2" so that the shell doesn't interpret it while
2164 # we're creating the awk script.
2165 # -------------------
2166 cat > /tmp
/find_disks.
awk <<EOF
2175 if (searchdisks && \$2 !~ "^$"){
2181 /^AVAILABLE DISK SELECTIONS:/{
2185 #---------------------
2187 chmod 755 /tmp
/find_disks.
awk
2188 disks
=${@:-$(echo "" | format -e 2>/dev/null | /tmp/find_disks.awk)}
2189 rm /tmp
/find_disks.
awk
2192 for disk
in $disks; do
2194 grep "${disk}[sp]" /etc
/mnttab
>/dev
/null
2195 (($?
== 0)) && continue
2197 grep "${disk}[sp]" $sfi >/dev
/null
2198 (($?
== 0)) && continue
2199 # check for dump device
2200 grep "${disk}[sp]" $dmpi >/dev
/null
2201 (($?
== 0)) && continue
2202 # check to see if this disk hasn't been explicitly excluded
2203 # by a user-set environment variable
2204 echo "${ZFS_HOST_DEVICES_IGNORE}" |
grep "${disk}" > /dev
/null
2205 (($?
== 0)) && continue
2206 unused_candidates
="$unused_candidates $disk"
2211 # now just check to see if those disks do actually exist
2212 # by looking for a device pointing to the first slice in
2213 # each case. limit the number to max_finddisksnum
2215 for disk
in $unused_candidates; do
2216 if [ -b $DEV_DSKDIR/${disk}s0
]; then
2217 if [ $count -lt $max_finddisksnum ]; then
2218 unused
="$unused $disk"
2219 # do not impose limit if $@ is provided
2220 [[ -z $@
]] && ((count
= count
+ 1))
2225 # finally, return our disk list
2230 # Add specified user to specified group
2234 # $3 base of the homedir (optional)
2236 function add_user
#<group_name> <user_name> <basedir>
2240 typeset basedir
=${3:-"/var/tmp"}
2242 if ((${#gname} == 0 ||
${#uname} == 0)); then
2243 log_fail
"group name or user name are not defined."
2246 log_must useradd
-g $gname -d $basedir/$uname -m $uname
2247 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.profile
2248 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.bash_profile
2249 echo "export PATH=\"$STF_PATH\"" >>$basedir/$uname/.login
2251 # Add new users to the same group and the command line utils.
2252 # This allows them to be run out of the original users home
2253 # directory as long as it permissioned to be group readable.
2255 cmd_group
=$
(stat
--format="%G" $
(which zfs
))
2256 log_must usermod
-a -G $cmd_group $uname
2263 # Delete the specified user.
2266 # $2 base of the homedir (optional)
2268 function del_user
#<logname> <basedir>
2271 typeset basedir
=${2:-"/var/tmp"}
2273 if ((${#user} == 0)); then
2274 log_fail
"login name is necessary."
2277 if id
$user > /dev
/null
2>&1; then
2278 log_must_retry
"currently used" 5 userdel
$user
2281 [[ -d $basedir/$user ]] && rm -fr $basedir/$user
2287 # Select valid gid and create specified group.
2291 function add_group
#<group_name>
2295 if ((${#group} == 0)); then
2296 log_fail
"group name is necessary."
2299 # Assign 100 as the base gid, a larger value is selected for
2300 # Linux because for many distributions 1000 and under are reserved.
2303 groupadd
$group > /dev
/null
2>&1
2313 groupadd
-g $gid $group > /dev
/null
2>&1
2317 # The gid is not unique
2326 # Delete the specified group.
2330 function del_group
#<group_name>
2333 if ((${#grp} == 0)); then
2334 log_fail
"group name is necessary."
2338 getent group
$grp > /dev
/null
2>&1
2341 # Group does not exist.
2343 # Name already exists as a group name
2344 0) log_must groupdel
$grp ;;
2348 groupmod
-n $grp $grp > /dev
/null
2>&1
2351 # Group does not exist.
2353 # Name already exists as a group name
2354 9) log_must groupdel
$grp ;;
2363 # This function will return true if it's safe to destroy the pool passed
2364 # as argument 1. It checks for pools based on zvols and files, and also
2365 # files contained in a pool that may have a different mountpoint.
2367 function safe_to_destroy_pool
{ # $1 the pool name
2370 typeset DONT_DESTROY
=""
2372 # We check that by deleting the $1 pool, we're not
2373 # going to pull the rug out from other pools. Do this
2374 # by looking at all other pools, ensuring that they
2375 # aren't built from files or zvols contained in this pool.
2377 for pool
in $
(zpool list
-H -o name
)
2381 # this is a list of the top-level directories in each of the
2382 # files that make up the path to the files the pool is based on
2383 FILEPOOL
=$
(zpool status
-v $pool |
grep /$1/ | \
2386 # this is a list of the zvols that make up the pool
2387 ZVOLPOOL
=$
(zpool status
-v $pool |
grep "$ZVOL_DEVDIR/$1$" \
2390 # also want to determine if it's a file-based pool using an
2391 # alternate mountpoint...
2392 POOL_FILE_DIRS
=$
(zpool status
-v $pool | \
2393 grep / |
awk '{print $1}' | \
2394 awk -F/ '{print $2}' |
grep -v "dev")
2396 for pooldir
in $POOL_FILE_DIRS
2398 OUTPUT
=$
(zfs list
-H -r -o mountpoint
$1 | \
2399 grep "${pooldir}$" |
awk '{print $1}')
2401 ALTMOUNTPOOL
="${ALTMOUNTPOOL}${OUTPUT}"
2405 if [ ! -z "$ZVOLPOOL" ]
2408 log_note
"Pool $pool is built from $ZVOLPOOL on $1"
2411 if [ ! -z "$FILEPOOL" ]
2414 log_note
"Pool $pool is built from $FILEPOOL on $1"
2417 if [ ! -z "$ALTMOUNTPOOL" ]
2420 log_note
"Pool $pool is built from $ALTMOUNTPOOL on $1"
2424 if [ -z "${DONT_DESTROY}" ]
2428 log_note
"Warning: it is not safe to destroy $1!"
2434 # Get the available ZFS compression options
2435 # $1 option type zfs_set|zfs_compress
2437 function get_compress_opts
2439 typeset COMPRESS_OPTS
2440 typeset GZIP_OPTS
="gzip gzip-1 gzip-2 gzip-3 gzip-4 gzip-5 \
2441 gzip-6 gzip-7 gzip-8 gzip-9"
2443 if [[ $1 == "zfs_compress" ]] ; then
2444 COMPRESS_OPTS
="on lzjb"
2445 elif [[ $1 == "zfs_set" ]] ; then
2446 COMPRESS_OPTS
="on off lzjb"
2448 typeset valid_opts
="$COMPRESS_OPTS"
2449 zfs get
2>&1 |
grep gzip >/dev
/null
2>&1
2450 if [[ $?
-eq 0 ]]; then
2451 valid_opts
="$valid_opts $GZIP_OPTS"
2457 # Verify zfs operation with -p option work as expected
2458 # $1 operation, value could be create, clone or rename
2459 # $2 dataset type, value could be fs or vol
2461 # $4 new dataset name
2463 function verify_opt_p_ops
2468 typeset newdataset
=$4
2470 if [[ $datatype != "fs" && $datatype != "vol" ]]; then
2471 log_fail
"$datatype is not supported."
2474 # check parameters accordingly
2479 if [[ $datatype == "vol" ]]; then
2480 ops
="create -V $VOLSIZE"
2484 if [[ -z $newdataset ]]; then
2485 log_fail
"newdataset should not be empty" \
2488 log_must datasetexists
$dataset
2489 log_must snapexists
$dataset
2492 if [[ -z $newdataset ]]; then
2493 log_fail
"newdataset should not be empty" \
2496 log_must datasetexists
$dataset
2497 log_mustnot snapexists
$dataset
2500 log_fail
"$ops is not supported."
2504 # make sure the upper level filesystem does not exist
2505 destroy_dataset
"${newdataset%/*}" "-rRf"
2507 # without -p option, operation will fail
2508 log_mustnot zfs
$ops $dataset $newdataset
2509 log_mustnot datasetexists
$newdataset ${newdataset%/*}
2511 # with -p option, operation should succeed
2512 log_must zfs
$ops -p $dataset $newdataset
2515 if ! datasetexists
$newdataset ; then
2516 log_fail
"-p option does not work for $ops"
2519 # when $ops is create or clone, redo the operation still return zero
2520 if [[ $ops != "rename" ]]; then
2521 log_must zfs
$ops -p $dataset $newdataset
2528 # Get configuration of pool
2538 if ! poolexists
"$pool" ; then
2541 alt_root
=$
(zpool list
-H $pool |
awk '{print $NF}')
2542 if [[ $alt_root == "-" ]]; then
2543 value
=$
(zdb
-C $pool |
grep "$config:" |
awk -F: \
2546 value
=$
(zdb
-e $pool |
grep "$config:" |
awk -F: \
2549 if [[ -n $value ]] ; then
2559 # Privated function. Random select one of items from arguments.
2564 function _random_get
2571 ((ind
= RANDOM
% cnt
+ 1))
2573 typeset ret
=$
(echo "$str" | cut
-f $ind -d ' ')
2578 # Random select one of item from arguments which include NONE string
2580 function random_get_with_non
2585 _random_get
"$cnt" "$@"
2589 # Random select one of item from arguments which doesn't include NONE string
2593 _random_get
"$#" "$@"
2597 # Detect if the current system support slog
2599 function verify_slog_support
2601 typeset dir
=$TEST_BASE_DIR/disk.$$
2607 mkfile
$MINVDEVSIZE $vdev $sdev
2610 if ! zpool create
-n $pool $vdev log
$sdev > /dev
/null
2>&1; then
2619 # The function will generate a dataset name with specific length
2620 # $1, the length of the name
2621 # $2, the base string to construct the name
2623 function gen_dataset_name
2626 typeset basestr
="$2"
2627 typeset
-i baselen
=${#basestr}
2631 if ((len
% baselen
== 0)); then
2632 ((iter
= len
/ baselen
))
2634 ((iter
= len
/ baselen
+ 1))
2636 while ((iter
> 0)); do
2637 l_name
="${l_name}$basestr"
2646 # Get cksum tuple of dataset
2649 # sample zdb output:
2650 # Dataset data/test [ZPL], ID 355, cr_txg 2413856, 31.0K, 7 objects, rootbp
2651 # DVA[0]=<0:803046400:200> DVA[1]=<0:81199000:200> [L0 DMU objset] fletcher4
2652 # lzjb LE contiguous unique double size=800L/200P birth=2413856L/2413856P
2653 # fill=7 cksum=11ce125712:643a9c18ee2:125e25238fca0:254a3f74b59744
2654 function datasetcksum
2658 cksum=$
(zdb
-vvv $1 |
grep "^Dataset $1 \[" |
grep "cksum" \
2659 |
awk -F= '{print $7}')
2670 cksum=$
(cksum $1 |
awk '{print $1}')
2675 # Get the given disk/slice state from the specific field of the pool
2677 function get_device_state
#pool disk field("", "spares","logs")
2680 typeset disk
=${2#$DEV_DSKDIR/}
2681 typeset field
=${3:-$pool}
2683 state
=$
(zpool status
-v "$pool" 2>/dev
/null | \
2684 nawk
-v device
=$disk -v pool
=$pool -v field
=$field \
2685 'BEGIN {startconfig=0; startfield=0; }
2686 /config:/ {startconfig=1}
2687 (startconfig==1) && ($1==field) {startfield=1; next;}
2688 (startfield==1) && ($1==device) {print $2; exit;}
2690 ($1==field || $1 ~ "^spares$" || $1 ~ "^logs$") {startfield=0}')
2696 # print the given directory filesystem type
2704 if [[ -z $dir ]]; then
2705 log_fail
"Usage: get_fstype <directory>"
2712 df
-n $dir |
awk '{print $3}'
2716 # Given a disk, label it to VTOC regardless what label was on the disk
2722 if [[ -z $disk ]]; then
2723 log_fail
"The disk name is unspecified."
2725 typeset label_file
=/var
/tmp
/labelvtoc.$$
2726 typeset arch
=$
(uname
-p)
2729 log_note
"Currently unsupported by the test framework"
2733 if [[ $arch == "i386" ]]; then
2734 echo "label" > $label_file
2735 echo "0" >> $label_file
2736 echo "" >> $label_file
2737 echo "q" >> $label_file
2738 echo "q" >> $label_file
2740 fdisk
-B $disk >/dev
/null
2>&1
2741 # wait a while for fdisk finishes
2743 elif [[ $arch == "sparc" ]]; then
2744 echo "label" > $label_file
2745 echo "0" >> $label_file
2746 echo "" >> $label_file
2747 echo "" >> $label_file
2748 echo "" >> $label_file
2749 echo "q" >> $label_file
2751 log_fail
"unknown arch type"
2754 format
-e -s -d $disk -f $label_file
2755 typeset
-i ret_val
=$?
2758 # wait the format to finish
2761 if ((ret_val
!= 0)); then
2762 log_fail
"unable to label $disk as VTOC."
2769 # check if the system was installed as zfsroot or not
2770 # return: 0 ture, otherwise false
2774 df
-n / |
grep zfs
> /dev
/null
2>&1
2779 # get the root filesystem name if it's zfsroot system.
2781 # return: root filesystem name
2787 rootfs
=$
(awk '{if ($2 == "/" && $3 == "zfs") print $1}' \
2790 if [[ -z "$rootfs" ]]; then
2791 log_fail
"Can not get rootfs"
2793 zfs list
$rootfs > /dev
/null
2>&1
2794 if (($?
== 0)); then
2797 log_fail
"This is not a zfsroot system."
2802 # get the rootfs's pool name
2806 function get_rootpool
2812 rootfs
=$
(awk '{if ($2 == "/" && $3 =="zfs") print $1}' \
2815 if [[ -z "$rootfs" ]]; then
2816 log_fail
"Can not get rootpool"
2818 zfs list
$rootfs > /dev
/null
2>&1
2819 if (($?
== 0)); then
2820 rootpool
=`echo $rootfs | awk -F\/ '{print $1}'`
2823 log_fail
"This is not a zfsroot system."
2828 # Get the package name
2830 function get_package_name
2832 typeset dirpath
=${1:-$STC_NAME}
2834 echo "SUNWstc-${dirpath}" |
/usr
/bin
/sed -e "s/\//-/g"
2838 # Get the word numbers from a string separated by white space
2840 function get_word_count
2846 # To verify if the require numbers of disks is given
2848 function verify_disk_count
2850 typeset
-i min
=${2:-1}
2852 typeset
-i count
=$
(get_word_count
"$1")
2854 if ((count
< min
)); then
2855 log_untested
"A minimum of $min disks is required to run." \
2856 " You specified $count disk(s)"
2860 function ds_is_volume
2862 typeset
type=$
(get_prop
type $1)
2863 [[ $type = "volume" ]] && return 0
2867 function ds_is_filesystem
2869 typeset
type=$
(get_prop
type $1)
2870 [[ $type = "filesystem" ]] && return 0
2874 function ds_is_snapshot
2876 typeset
type=$
(get_prop
type $1)
2877 [[ $type = "snapshot" ]] && return 0
2882 # Check if Trusted Extensions are installed and enabled
2884 function is_te_enabled
2886 svcs
-H -o state labeld
2>/dev
/null |
grep "enabled"
2887 if (($?
!= 0)); then
2894 # Utility function to determine if a system has multiple cpus.
2900 (($
(psrinfo |
wc -l) > 1))
2906 function get_cpu_freq
2909 lscpu |
awk '/CPU MHz/ { print $3 }'
2911 psrinfo
-v 0 |
awk '/processor operates at/ {print $6}'
2915 # Run the given command as the user provided.
2921 log_note
"user:$user $@"
2922 eval su
- \
$user -c \"$@
\" > /tmp
/out
2>/tmp
/err
2927 # Check if the pool contains the specified vdevs
2932 # Return 0 if the vdevs are contained in the pool, 1 if any of the specified
2933 # vdevs is not in the pool, and 2 if pool name is missing.
2935 function vdevs_in_pool
2940 if [[ -z $pool ]]; then
2941 log_note
"Missing pool name."
2947 typeset tmpfile
=$
(mktemp
)
2948 zpool list
-Hv "$pool" >$tmpfile
2950 grep -w ${vdev##*/} $tmpfile >/dev
/null
2>&1
2951 [[ $?
-ne 0 ]] && return 1
2965 max
=$
(echo $
((max
> i ? max
: i
)))
2977 min
=$
(echo $
((min
< i ? min
: i
)))
2984 # Generate a random number between 1 and the argument.
2989 echo $
(( ($RANDOM % $max) + 1 ))
2992 # Write data that can be compressed into a directory
2993 function write_compressible
2997 typeset nfiles
=${3:-1}
2998 typeset bs
=${4:-1024k}
2999 typeset fname
=${5:-file}
3001 [[ -d $dir ]] || log_fail
"No directory: $dir"
3003 # Under Linux fio is not currently used since its behavior can
3004 # differ significantly across versions. This includes missing
3005 # command line options and cases where the --buffer_compress_*
3006 # options fail to behave as expected.
3008 typeset file_bytes
=$
(to_bytes
$megs)
3009 typeset bs_bytes
=4096
3010 typeset blocks
=$
(($file_bytes / $bs_bytes))
3012 for (( i
= 0; i
< $nfiles; i
++ )); do
3013 truncate
-s $file_bytes $dir/$fname.
$i
3015 # Write every third block to get 66% compression.
3016 for (( j
= 0; j
< $blocks; j
+= 3 )); do
3017 dd if=/dev
/urandom of
=$dir/$fname.
$i \
3018 seek
=$j bs
=$bs_bytes count
=1 \
3019 conv
=notrunc
>/dev
/null
2>&1
3023 log_must
eval "fio \
3028 --buffer_compress_percentage=66 \
3029 --buffer_compress_chunk=4096 \
3036 --filename_format='$fname.\$jobnum' >/dev/null"
3045 [[ -e $pathname ]] || log_fail
"No such file or directory: $pathname"
3046 objnum
=$
(stat
-c %i
$pathname)
3051 # Sync data to the pool
3054 # $2 boolean to force uberblock (and config including zpool cache file) update
3056 function sync_pool
#pool <force>
3058 typeset pool
=${1:-$TESTPOOL}
3059 typeset force
=${2:-false}
3061 if [[ $force == true
]]; then
3062 log_must zpool sync
-f $pool
3064 log_must zpool sync
$pool
3071 # Wait for zpool 'freeing' property drops to zero.
3075 function wait_freeing
#pool
3077 typeset pool
=${1:-$TESTPOOL}
3079 [[ "0" == "$(zpool list -Ho freeing $pool)" ]] && break
3085 # Wait for every device replace operation to complete
3089 function wait_replacing
#pool
3091 typeset pool
=${1:-$TESTPOOL}
3093 [[ "" == "$(zpool status $pool |
3094 awk '/replacing-[0-9]+/ {print $1}')" ]] && break
3100 # Wait for a pool to be scrubbed
3103 # $2 number of seconds to wait (optional)
3105 # Returns true when pool has been scrubbed, or false if there's a timeout or if
3106 # no scrub was done.
3108 function wait_scrubbed
3110 typeset pool
=${1:-$TESTPOOL}
3111 typeset iter
=${2:-10}
3112 for i
in {1..
$iter} ; do
3113 if is_pool_scrubbed
$pool ; then
3121 # Backup the zed.rc in our test directory so that we can edit it for our test.
3123 # Returns: Backup file name. You will need to pass this to zed_rc_restore().
3124 function zed_rc_backup
3126 zedrc_backup
="$(mktemp)"
3127 cp $ZEDLET_DIR/zed.rc
$zedrc_backup
3131 function zed_rc_restore
3133 mv $1 $ZEDLET_DIR/zed.rc
3137 # Setup custom environment for the ZED.
3139 # $@ Optional list of zedlets to run under zed.
3146 if [[ ! -d $ZEDLET_DIR ]]; then
3147 log_must mkdir
$ZEDLET_DIR
3150 if [[ ! -e $VDEVID_CONF ]]; then
3151 log_must
touch $VDEVID_CONF
3154 if [[ -e $VDEVID_CONF_ETC ]]; then
3155 log_fail
"Must not have $VDEVID_CONF_ETC file present on system"
3159 # Create a symlink for /etc/zfs/vdev_id.conf file.
3160 log_must
ln -s $VDEVID_CONF $VDEVID_CONF_ETC
3162 # Setup minimal ZED configuration. Individual test cases should
3163 # add additional ZEDLETs as needed for their specific test.
3164 log_must
cp ${ZEDLET_ETC_DIR}/zed.rc
$ZEDLET_DIR
3165 log_must
cp ${ZEDLET_ETC_DIR}/zed-functions.sh
$ZEDLET_DIR
3167 # Scripts must only be user writable.
3168 if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3169 saved_umask
=$
(umask)
3171 for i
in $EXTRA_ZEDLETS ; do
3172 log_must
cp ${ZEDLET_LIBEXEC_DIR}/$i $ZEDLET_DIR
3174 log_must
umask $saved_umask
3177 # Customize the zed.rc file to enable the full debug log.
3178 log_must
sed -i '/\#ZED_DEBUG_LOG=.*/d' $ZEDLET_DIR/zed.rc
3179 echo "ZED_DEBUG_LOG=$ZED_DEBUG_LOG" >>$ZEDLET_DIR/zed.rc
3184 # Cleanup custom ZED environment.
3186 # $@ Optional list of zedlets to remove from our test zed.d directory.
3187 function zed_cleanup
3194 log_must
rm -f ${ZEDLET_DIR}/zed.rc
3195 log_must
rm -f ${ZEDLET_DIR}/zed-functions.sh
3196 log_must
rm -f ${ZEDLET_DIR}/all-syslog.sh
3197 log_must
rm -f ${ZEDLET_DIR}/all-debug.sh
3198 log_must
rm -f ${ZEDLET_DIR}/state
3200 if [[ -n "$EXTRA_ZEDLETS" ]] ; then
3201 for i
in $EXTRA_ZEDLETS ; do
3202 log_must
rm -f ${ZEDLET_DIR}/$i
3205 log_must
rm -f $ZED_LOG
3206 log_must
rm -f $ZED_DEBUG_LOG
3207 log_must
rm -f $VDEVID_CONF_ETC
3208 log_must
rm -f $VDEVID_CONF
3213 # Check if ZED is currently running, if not start ZED.
3221 # ZEDLET_DIR=/var/tmp/zed
3222 if [[ ! -d $ZEDLET_DIR ]]; then
3223 log_must mkdir
$ZEDLET_DIR
3226 # Verify the ZED is not already running.
3227 pgrep
-x zed
> /dev
/null
3228 if (($?
== 0)); then
3229 log_fail
"ZED already running"
3232 log_note
"Starting ZED"
3233 # run ZED in the background and redirect foreground logging
3234 # output to $ZED_LOG.
3235 log_must truncate
-s 0 $ZED_DEBUG_LOG
3236 log_must
eval "zed -vF -d $ZEDLET_DIR -p $ZEDLET_DIR/zed.pid -P $PATH" \
3237 "-s $ZEDLET_DIR/state 2>$ZED_LOG &"
3251 log_note
"Stopping ZED"
3252 if [[ -f ${ZEDLET_DIR}/zed.pid
]]; then
3253 zedpid
=$
(cat ${ZEDLET_DIR}/zed.pid
)
3255 while ps
-p $zedpid > /dev
/null
; do
3258 rm -f ${ZEDLET_DIR}/zed.pid
3266 function zed_events_drain
3268 while [ $
(zpool events
-H |
wc -l) -ne 0 ]; do
3270 zpool events
-c >/dev
/null
3274 # Set a variable in zed.rc to something, un-commenting it in the process.
3284 eval sed -i $cmd $ZEDLET_DIR/zed.rc
3287 echo "$var=$val" >> $ZEDLET_DIR/zed.rc
3292 # Check is provided device is being active used as a swap device.
3294 function is_swap_inuse
3298 if [[ -z $device ]] ; then
3299 log_note
"No device specified."
3304 swapon
-s |
grep -w $
(readlink
-f $device) > /dev
/null
2>&1
3306 swap
-l |
grep -w $device > /dev
/null
2>&1
3313 # Setup a swap device using the provided device.
3320 log_must
eval "mkswap $swapdev > /dev/null 2>&1"
3321 log_must swapon
$swapdev
3323 log_must swap
-a $swapdev
3330 # Cleanup a swap device on the provided device.
3332 function swap_cleanup
3336 if is_swap_inuse
$swapdev; then
3338 log_must swapoff
$swapdev
3340 log_must swap
-d $swapdev
3348 # Set a global system tunable (64-bit value)
3353 function set_tunable64
3355 set_tunable_impl
"$1" "$2" Z
3359 # Set a global system tunable (32-bit value)
3364 function set_tunable32
3366 set_tunable_impl
"$1" "$2" W
3369 function set_tunable_impl
3371 typeset tunable
="$1"
3373 typeset mdb_cmd
="$3"
3374 typeset module
="${4:-zfs}"
3376 [[ -z "$tunable" ]] && return 1
3377 [[ -z "$value" ]] && return 1
3378 [[ -z "$mdb_cmd" ]] && return 1
3382 typeset zfs_tunables
="/sys/module/$module/parameters"
3383 [[ -w "$zfs_tunables/$tunable" ]] ||
return 1
3384 echo -n "$value" > "$zfs_tunables/$tunable"
3388 [[ "$module" -eq "zfs" ]] ||
return 1
3389 echo "${tunable}/${mdb_cmd}0t${value}" | mdb
-kw
3396 # Get a global system tunable
3400 function get_tunable
3402 get_tunable_impl
"$1"
3405 function get_tunable_impl
3407 typeset tunable
="$1"
3408 typeset module
="${2:-zfs}"
3410 [[ -z "$tunable" ]] && return 1
3414 typeset zfs_tunables
="/sys/module/$module/parameters"
3415 [[ -f "$zfs_tunables/$tunable" ]] ||
return 1
3416 cat $zfs_tunables/$tunable
3420 [[ "$module" -eq "zfs" ]] ||
return 1