3 # ZPOOL fault verification test script.
5 # The current suite of fault tests should not be thought of an exhaustive
6 # list of failure modes. Rather it is simply an starting point which trys
7 # to cover the bulk the of the 'easy' and hopefully common, failure modes.
9 # Additional tests should be added but the current suite as new interesting
10 # failures modes are observed. Additional failure modes I'd like to see
11 # tests for include, but are not limited too:
13 # * Slow but successful IO.
14 # * SCSI sense codes generated as zevents.
20 # The current infrastructure using the 'mdadm' faulty device and the
21 # 'scsi_debug' simulated scsi devices. The idea is to inject the error
22 # below the zfs stack to validate all the error paths. More targeted
23 # failure testing should be added using the 'zinject' command line util.
25 # Requires the following packages:
31 basedir="$(dirname $0)"
33 SCRIPT_COMMON=common.sh
34 if [ -f "${basedir}/${SCRIPT_COMMON}" ]; then
35 . "${basedir}/${SCRIPT_COMMON}"
37 echo "Missing helper script ${SCRIPT_COMMON}" && exit 1
48 ZPOOL fault verification tests
53 -c Cleanup md+lo+file devices at start
54 -t <#> Run listed tests
55 -s <#> Skip listed tests
60 while getopts 'hvct:s:?' OPTION; do
85 if [ $(id -u) != 0 ]; then
86 die "Must run as root"
89 # Perform pre-cleanup is requested
90 if [ ${CLEANUP} ]; then
94 rm -f /tmp/zpool.cache.*
97 # Check if we need to skip all md based tests.
99 check_md_partitionable && MD_PARTITIONABLE=1
100 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
101 echo "Skipping tests 1-7 which require partitionable md devices"
104 # Check if we need to skip all the scsi_debug tests.
106 ${INFOMOD} scsi_debug &>/dev/null && SCSI_DEBUG=1
107 if [ ${SCSI_DEBUG} -eq 0 ]; then
108 echo "Skipping tests 8-9 which require the scsi_debug module"
111 if [ ${MD_PARTITIONABLE} -eq 0 ] || [ ${SCSI_DEBUG} -eq 0 ]; then
115 printf "%40s%s\t%s\t%s\t%s\t%s\n" "" "raid0" "raid10" "raidz" "raidz2" "raidz3"
118 echo -n -e "${COLOR_GREEN}Pass${COLOR_RESET}\t"
122 echo -n -e "${COLOR_BROWN}Skip${COLOR_RESET}\t"
130 ${ZPOOL} status ${POOL_NAME} | grep ${DEVICE_TYPE} ${TMP_STATUS} | \
131 head -n${DEVICE_NTH} | tail -n1 | ${AWK} "{ print \$1 }"
138 ${ZPOOL} status ${POOL_NAME} | ${AWK} "/${VDEV_NAME}/ { print \$2 }"
141 # Required format is x.yz[KMGTP]
142 expand_numeric_suffix() {
145 VALUE=`echo "${VALUE/%K/*1000}"`
146 VALUE=`echo "${VALUE/%M/*1000000}"`
147 VALUE=`echo "${VALUE/%G/*1000000000}"`
148 VALUE=`echo "${VALUE/%T/*1000000000000}"`
149 VALUE=`echo "${VALUE/%P/*1000000000000000}"`
150 VALUE=`echo "${VALUE}" | bc | cut -d'.' -f1`
158 local VDEV_ERRORS=`${ZPOOL} status ${POOL_NAME} |
159 ${AWK} "/${VDEV_NAME}/ { print \\$3 }"`
161 expand_numeric_suffix ${VDEV_ERRORS}
164 vdev_write_errors() {
167 local VDEV_ERRORS=`${ZPOOL} status ${POOL_NAME} |
168 ${AWK} "/${VDEV_NAME}/ { print \\$4 }"`
170 expand_numeric_suffix ${VDEV_ERRORS}
173 vdev_cksum_errors() {
176 local VDEV_ERRORS=`${ZPOOL} status ${POOL_NAME} |
177 ${AWK} "/${VDEV_NAME}/ { print \\$5 }"`
179 expand_numeric_suffix ${VDEV_ERRORS}
185 ${ZPOOL} status ${POOL_NAME} | ${AWK} "/state/ { print \$2; exit }"
192 SCRIPT1="BEGIN {RS=\"\"; FS=\"\n\"} /${EVENT_NAME}/ { print \$0; exit }"
193 SCRIPT2="BEGIN {FS=\"=\"} /${EVENT_KEY}/ { print \$2; exit }"
195 ${ZPOOL} events -vH | ${AWK} "${SCRIPT1}" | ${AWK} "${SCRIPT2}"
198 zpool_scan_errors() {
201 ${ZPOOL} status ${POOL_NAME} | ${AWK} "/scan: scrub/ { print \$8 }"
202 ${ZPOOL} status ${POOL_NAME} | ${AWK} "/scan: resilver/ { print \$7 }"
206 local PATTERN_BLOCK_SIZE=$1
207 local PATTERN_BLOCK_COUNT=$2
208 local PATTERN_NAME=`mktemp -p /tmp zpool.pattern.XXXXXXXX`
211 dd if=/dev/urandom of=${PATTERN_NAME} bs=${PATTERN_BLOCK_SIZE} \
212 count=${PATTERN_BLOCK_COUNT} &>/dev/null
217 local PATTERN_NAME=$1
218 local PATTERN_BLOCK_SIZE=$2
219 local PATTERN_BLOCK_COUNT=$3
222 dd if=${PATTERN_NAME} of=${DEVICE_NAME} bs=${PATTERN_BLOCK_SIZE} \
223 count=${PATTERN_BLOCK_COUNT} oflag=direct &>/dev/null
228 local PATTERN_NAME=$1
229 local PATTERN_BLOCK_SIZE=$2
230 local PATTERN_BLOCK_COUNT=$3
233 dd if=${PATTERN_NAME} of=${DEVICE_NAME} bs=${PATTERN_BLOCK_SIZE} \
234 count=${PATTERN_BLOCK_COUNT} oflag=direct &>/dev/null &
239 local PATTERN_NAME=$1
240 local PATTERN_BLOCK_SIZE=$2
241 local PATTERN_BLOCK_COUNT=$3
243 local DEVICE_FILE=`mktemp -p /tmp zpool.pattern.XXXXXXXX`
245 dd if=${DEVICE_NAME} of=${DEVICE_FILE} bs=${PATTERN_BLOCK_SIZE} \
246 count=${PATTERN_BLOCK_COUNT} iflag=direct &>/dev/null
247 cmp -s ${PATTERN_NAME} ${DEVICE_FILE}
255 local PATTERN_NAME=$1
257 rm -f ${PATTERN_NAME}
265 ${MDADM} /dev/${VDEV_FAULTY} --grow --level=faulty \
266 --layout=${FAULT_TYPE} >/dev/null
273 # Clear all failure injection.
274 ${MDADM} /dev/${VDEV_FAULTY} --grow --level=faulty \
275 --layout=clear >/dev/null || return $?
276 ${MDADM} /dev/${VDEV_FAULTY} --grow --level=faulty \
277 --layout=flush >/dev/null || return $?
285 echo ${OPTS} >/sys/bus/pseudo/drivers/scsi_debug/opts
286 echo ${NTH} >/sys/bus/pseudo/drivers/scsi_debug/every_nth
290 echo 0 >/sys/bus/pseudo/drivers/scsi_debug/every_nth
291 echo 0 >/sys/bus/pseudo/drivers/scsi_debug/opts
300 ${ZFS_SH} zfs="spa_config_path=${TMP_CACHE}" || fail 1
301 ${ZPOOL_CREATE_SH} -p ${POOL_NAME} -c ${POOL_CONFIG} || fail 2
302 ${ZFS} create -V 64M ${POOL_NAME}/${ZVOL_NAME} || fail 3
304 # Trigger udev and re-read the partition table to ensure all of
305 # this IO is out of the way before we begin injecting failures.
306 udev_trigger || fail 4
307 ${BLOCKDEV} --rereadpt /dev/${POOL_NAME}/${ZVOL_NAME} || fail 5
316 ${ZFS} destroy ${POOL_NAME}/${ZVOL_NAME} || fail 101
317 ${ZPOOL_CREATE_SH} -p ${POOL_NAME} -c ${POOL_CONFIG} -d || fail 102
318 ${ZFS_SH} -u || fail 103
319 rm -f ${TMP_CACHE} || fail 104
325 local POOL_REDUNDANT=$3
326 local ZVOL_NAME="zvol"
327 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
329 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
334 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
335 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
337 # Set soft write failure for first vdev device.
338 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md 1`
339 fault_set_md ${VDEV_FAULTY} write-transient
341 # The application must not observe an error.
342 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
343 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
344 fault_clear_md ${VDEV_FAULTY}
346 # Soft errors will not be logged to 'zpool status'
347 local WRITE_ERRORS=`vdev_write_errors ${POOL_NAME} ${VDEV_FAULTY}`
348 test ${WRITE_ERRORS} -eq 0 || fail 13
350 # Soft errors will still generate an EIO (5) event.
351 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 14
353 # Verify the known pattern.
354 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 15
355 pattern_remove ${TMP_PATTERN} || fail 16
357 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
363 test_write_soft tank lo-faulty-raid0 0
364 test_write_soft tank lo-faulty-raid10 1
365 test_write_soft tank lo-faulty-raidz 1
366 test_write_soft tank lo-faulty-raidz2 1
367 test_write_soft tank lo-faulty-raidz3 1
370 run_test 1 "soft write error"
375 local POOL_REDUNDANT=$3
376 local ZVOL_NAME="zvol"
377 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
379 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
384 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
385 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
387 # Set hard write failure for first vdev device.
388 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md 1`
389 fault_set_md ${VDEV_FAULTY} write-persistent
391 # The application must not observe an error.
392 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
393 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
394 fault_clear_md ${VDEV_FAULTY}
396 local WRITE_ERRORS=`vdev_write_errors ${POOL_NAME} ${VDEV_FAULTY}`
397 if [ ${POOL_REDUNDANT} -eq 1 ]; then
398 # For redundant configurations hard errors will not be
399 # logged to 'zpool status' but will generate EIO events.
400 test ${WRITE_ERRORS} -eq 0 || fail 21
401 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 22
403 # For non-redundant configurations hard errors will be
404 # logged to 'zpool status' and generate EIO events. They
405 # will also trigger a scrub of the impacted sectors.
407 test ${WRITE_ERRORS} -gt 0 || fail 31
408 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 32
409 test `zpool_event "zfs.resilver.start" "ena"` != "" || fail 33
410 test `zpool_event "zfs.resilver.finish" "ena"` != "" || fail 34
411 test `zpool_scan_errors ${POOL_NAME}` -eq 0 || fail 35
414 # Verify the known pattern.
415 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 41
416 pattern_remove ${TMP_PATTERN} || fail 42
418 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
424 test_write_hard tank lo-faulty-raid0 0
425 test_write_hard tank lo-faulty-raid10 1
426 test_write_hard tank lo-faulty-raidz 1
427 test_write_hard tank lo-faulty-raidz2 1
428 test_write_hard tank lo-faulty-raidz3 1
431 run_test 2 "hard write error"
436 local POOL_REDUNDANT=$3
437 local ZVOL_NAME="zvol"
438 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
440 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
445 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
446 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
448 # Set all write failures for first vdev device.
449 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md 1`
450 fault_set_md ${VDEV_FAULTY} write-all
452 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
453 if [ ${POOL_REDUNDANT} -eq 1 ]; then
454 # The application must not observe an error.
455 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
457 # The application is expected to hang in the background until
458 # the faulty device is repaired and 'zpool clear' is run.
459 pattern_write_bg ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 13
462 fault_clear_md ${VDEV_FAULTY}
464 local WRITE_ERRORS=`vdev_write_errors ${POOL_NAME} ${VDEV_FAULTY}`
465 local VDEV_STATUS=`vdev_status ${POOL_NAME} ${VDEV_FAULTY}`
466 local POOL_STATE=`zpool_state ${POOL_NAME}`
467 # For all configurations write errors are logged to 'zpool status',
468 # and EIO events are generated. However, only a redundant config
469 # will cause the vdev to be FAULTED and pool DEGRADED. In a non-
470 # redundant config the IO will hang until 'zpool clear' is run.
471 test ${WRITE_ERRORS} -gt 0 || fail 14
472 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 15
474 if [ ${POOL_REDUNDANT} -eq 1 ]; then
475 test "${VDEV_STATUS}" = "FAULTED" || fail 21
476 test "${POOL_STATE}" = "DEGRADED" || fail 22
478 BLOCKED=`ps a | grep "${ZVOL_DEVICE}" | grep -c -v "grep"`
479 ${ZPOOL} clear ${POOL_NAME} || fail 31
480 test ${BLOCKED} -eq 1 || fail 32
484 # Verify the known pattern.
485 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 41
486 pattern_remove ${TMP_PATTERN} || fail 42
488 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
494 test_write_all tank lo-faulty-raid0 0
495 test_write_all tank lo-faulty-raid10 1
496 test_write_all tank lo-faulty-raidz 1
497 test_write_all tank lo-faulty-raidz2 1
498 test_write_all tank lo-faulty-raidz3 1
501 run_test 3 "all write errors"
506 local POOL_REDUNDANT=$3
507 local ZVOL_NAME="zvol"
508 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
511 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
516 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
517 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
519 # Create a pattern to be verified during a read error.
520 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
521 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
523 # Set soft read failure for all the vdevs to ensure we hit it.
524 for (( i=1; i<=4; i++ )); do
525 fault_set_md `nth_zpool_vdev ${POOL_NAME} md $i` read-transient
528 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 13
529 pattern_remove ${TMP_PATTERN} || fail 14
531 # Clear all failure injection and sum read errors.
532 for (( i=1; i<=4; i++ )); do
533 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md $i`
534 local VDEV_ERRORS=`vdev_read_errors ${POOL_NAME} ${VDEV_FAULTY}`
535 let READ_ERRORS=${READ_ERRORS}+${VDEV_ERRORS}
536 fault_clear_md ${VDEV_FAULTY}
539 # Soft errors will not be logged to 'zpool status'.
540 test ${READ_ERRORS} -eq 0 || fail 15
542 # Soft errors will still generate an EIO (5) event.
543 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 16
545 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
551 test_read_soft tank lo-faulty-raid0 0
552 test_read_soft tank lo-faulty-raid10 1
553 test_read_soft tank lo-faulty-raidz 1
554 test_read_soft tank lo-faulty-raidz2 1
555 test_read_soft tank lo-faulty-raidz3 1
558 run_test 4 "soft read error"
563 local POOL_REDUNDANT=$3
564 local ZVOL_NAME="zvol"
565 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
568 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
573 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
574 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
576 # Create a pattern to be verified during a read error.
577 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
578 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
580 # Set hard read failure for the fourth vdev.
581 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md 4`
582 fault_set_md ${VDEV_FAULTY} read-persistent
584 # For a redundant pool there must be no IO error, for a non-redundant
585 # pool we expect permanent damage and an IO error during verify, unless
586 # we get exceptionally lucky and have just damaged redundant metadata.
587 if [ ${POOL_REDUNDANT} -eq 1 ]; then
588 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 21
589 local READ_ERRORS=`vdev_read_errors ${POOL_NAME} ${VDEV_FAULTY}`
590 test ${READ_ERRORS} -eq 0 || fail 22
592 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE}
593 ${ZPOOL} scrub ${POOL_NAME} || fail 32
594 local READ_ERRORS=`vdev_read_errors ${POOL_NAME} ${VDEV_FAULTY}`
595 test ${READ_ERRORS} -gt 0 || fail 33
596 ${ZPOOL} status -v ${POOL_NAME} | \
597 grep -A8 "Permanent errors" | \
598 grep -q "${POOL_NAME}" || fail 34
600 pattern_remove ${TMP_PATTERN} || fail 41
602 # Clear all failure injection and sum read errors.
603 fault_clear_md ${VDEV_FAULTY}
605 # Hard errors will generate an EIO (5) event.
606 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 42
608 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
614 test_read_hard tank lo-faulty-raid0 0
615 test_read_hard tank lo-faulty-raid10 1
616 test_read_hard tank lo-faulty-raidz 1
617 test_read_hard tank lo-faulty-raidz2 1
618 test_read_hard tank lo-faulty-raidz3 1
621 run_test 5 "hard read error"
623 # Fixable read error.
624 test_read_fixable() {
627 local POOL_REDUNDANT=$3
628 local ZVOL_NAME="zvol"
629 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
632 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
637 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
638 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
640 # Create a pattern to be verified during a read error.
641 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
642 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
644 # Set hard read failure for the fourth vdev.
645 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md 4`
646 fault_set_md ${VDEV_FAULTY} read-fixable
648 # For a redundant pool there must be no IO error, for a non-redundant
649 # pool we expect permanent damage and an IO error during verify, unless
650 # we get exceptionally lucky and have just damaged redundant metadata.
651 if [ ${POOL_REDUNDANT} -eq 1 ]; then
652 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 21
653 local READ_ERRORS=`vdev_read_errors ${POOL_NAME} ${VDEV_FAULTY}`
654 test ${READ_ERRORS} -eq 0 || fail 22
656 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE}
657 ${ZPOOL} scrub ${POOL_NAME} || fail 32
658 local READ_ERRORS=`vdev_read_errors ${POOL_NAME} ${VDEV_FAULTY}`
659 test ${READ_ERRORS} -gt 0 || fail 33
660 ${ZPOOL} status -v ${POOL_NAME} | \
661 grep -A8 "Permanent errors" | \
662 grep -q "${POOL_NAME}" || fail 34
664 pattern_remove ${TMP_PATTERN} || fail 41
666 # Clear all failure injection and sum read errors.
667 fault_clear_md ${VDEV_FAULTY}
669 # Hard errors will generate an EIO (5) event.
670 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 42
672 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
676 # Read errors fixable with a write.
678 test_read_fixable tank lo-faulty-raid0 0
679 test_read_fixable tank lo-faulty-raid10 1
680 test_read_fixable tank lo-faulty-raidz 1
681 test_read_fixable tank lo-faulty-raidz2 1
682 test_read_fixable tank lo-faulty-raidz3 1
685 run_test 6 "fixable read error"
690 local POOL_REDUNDANT=$3
691 local VDEV_DAMAGE="$4"
692 local ZVOL_NAME="zvol"
693 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
695 if [ ${MD_PARTITIONABLE} -eq 0 ]; then
700 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
701 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
703 # Create a pattern to be verified.
704 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
705 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
707 # Verify the pattern and that no vdev has cksum errors.
708 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 13
709 for (( i=1; i<4; i++ )); do
710 VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md ${i}`
711 CKSUM_ERRORS=`vdev_cksum_errors ${POOL_NAME} ${VDEV_FAULTY}`
712 test ${CKSUM_ERRORS} -eq 0 || fail 14
715 # Corrupt the bulk of a vdev with random garbage, we damage as many
716 # vdevs as we have levels of redundancy. For example for a raidz3
717 # configuration we can trash 3 vdevs and still expect correct data.
718 # This improves the odds that we read one of the damaged vdevs.
719 for VDEV in ${VDEV_DAMAGE}; do
720 VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} md $VDEV`
721 pattern_write /dev/urandom 1M 64 /dev/${VDEV_FAULTY}p1
724 # Verify the pattern is still correct. For non-redundant pools
725 # expect failure and for redundant pools success due to resilvering.
726 if [ ${POOL_REDUNDANT} -eq 1 ]; then
727 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 16
729 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} && fail 17
732 CKSUM_ERRORS=`vdev_cksum_errors ${POOL_NAME} ${VDEV_FAULTY}`
733 test ${CKSUM_ERRORS} -gt 0 || fail 18
734 STATUS=`vdev_status ${POOL_NAME} ${VDEV_FAULTY}`
735 test "${STATUS}" = "ONLINE" || fail 19
737 # The checksum errors must be logged as an event.
738 local CKSUM_ERRORS=`zpool_event "zfs.checksum" "zio_err"`
739 test ${CKSUM_ERRORS} = "0x34" || test ${CKSUM_ERRORS} = "0x0" || fail 20
741 # Verify permant errors for non-redundant pools, and for redundant
742 # pools trigger a scrub and check that all checksums have been fixed.
743 if [ ${POOL_REDUNDANT} -eq 1 ]; then
744 # Scrub the checksum errors and clear the faults.
745 ${ZPOOL} scrub ${POOL_NAME} || fail 21
747 ${ZPOOL} clear ${POOL_NAME} || fail 22
749 # Re-verify the pattern for fixed checksums.
750 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 23
751 CKSUM_ERRORS=`vdev_cksum_errors ${POOL_NAME} ${VDEV_FAULTY}`
752 test ${CKSUM_ERRORS} -eq 0 || fail 24
754 # Re-verify the entire pool for fixed checksums.
755 ${ZPOOL} scrub ${POOL_NAME} || fail 25
756 CKSUM_ERRORS=`vdev_cksum_errors ${POOL_NAME} ${VDEV_FAULTY}`
757 test ${CKSUM_ERRORS} -eq 0 || fail 26
759 ${ZPOOL} status -v ${POOL_NAME} | \
760 grep -A8 "Permanent errors" | \
761 grep -q "${POOL_NAME}/${ZVOL_NAME}" || fail 31
762 ${ZPOOL} clear ${POOL_NAME} || fail 32
764 pattern_remove ${TMP_PATTERN} || fail 41
766 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
770 # Silent data corruption
772 test_cksum tank lo-faulty-raid0 0 "1"
773 test_cksum tank lo-faulty-raid10 1 "1 3"
774 test_cksum tank lo-faulty-raidz 1 "4"
775 test_cksum tank lo-faulty-raidz2 1 "3 4"
776 test_cksum tank lo-faulty-raidz3 1 "2 3 4"
779 run_test 7 "silent data corruption"
781 # Soft write timeout at the scsi device layer.
782 test_write_timeout_soft() {
785 local POOL_REDUNDANT=$3
787 local ZVOL_NAME="zvol"
788 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
790 if [ ${SCSI_DEBUG} -eq 0 ]; then
795 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
796 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
798 # Set timeout(0x4) for every nth command.
799 fault_set_sd 4 ${POOL_NTH}
801 # The application must not observe an error.
802 local TMP_PATTERN=`pattern_create 1M 8` || fail 11
803 pattern_write ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 12
806 # Intermittent write timeouts even with FAILFAST set may not cause
807 # an EIO (5) event. This is because how FAILFAST is handled depends
808 # a log on the low level driver and the exact nature of the failure.
809 # We will however see a 'zfs.delay' event logged due to the timeout.
810 VDEV_DELAY=`zpool_event "zfs.delay" "zio_delay"`
811 test `printf "%d" ${VDEV_DELAY}` -ge 30000 || fail 13
813 # Verify the known pattern.
814 pattern_verify ${TMP_PATTERN} 1M 8 ${ZVOL_DEVICE} || fail 14
815 pattern_remove ${TMP_PATTERN} || fail 15
817 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
822 test_write_timeout_soft tank scsi_debug-raid0 0 50
823 test_write_timeout_soft tank scsi_debug-raid10 1 100
824 test_write_timeout_soft tank scsi_debug-raidz 1 75
825 test_write_timeout_soft tank scsi_debug-raidz2 1 150
826 test_write_timeout_soft tank scsi_debug-raidz3 1 300
829 run_test 8 "soft write timeout"
831 # Persistent write timeout at the scsi device layer.
832 test_write_timeout_hard() {
835 local POOL_REDUNDANT=$3
837 local ZVOL_NAME="zvol"
838 local ZVOL_DEVICE="/dev/${POOL_NAME}/${ZVOL_NAME}"
841 if [ ${SCSI_DEBUG} -eq 0 ]; then
846 local TMP_CACHE=`mktemp -p /tmp zpool.cache.XXXXXXXX`
847 test_setup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
849 local TMP_PATTERN1=`pattern_create 1M 8`
850 local TMP_PATTERN2=`pattern_create 1M 8`
851 local TMP_PATTERN3=`pattern_create 1M 8`
853 # Create three partitions each one gets a unique pattern. The first
854 # pattern is written before the failure, the second pattern during
855 # the failure, and the third pattern while the vdev is degraded.
856 # All three patterns are verified while the vdev is degraded and
857 # then again once it is brought back online.
858 ${PARTED} -s ${ZVOL_DEVICE} mklabel gpt || fail 11
859 ${PARTED} -s ${ZVOL_DEVICE} mkpart primary 1M 16M || fail 12
860 ${PARTED} -s ${ZVOL_DEVICE} mkpart primary 16M 32M || fail 13
861 ${PARTED} -s ${ZVOL_DEVICE} mkpart primary 32M 48M || fail 14
863 wait_udev ${ZVOL_DEVICE}1 30
864 wait_udev ${ZVOL_DEVICE}2 30
865 wait_udev ${ZVOL_DEVICE}3 30
867 # Before the failure.
868 pattern_write ${TMP_PATTERN1} 1M 8 ${ZVOL_DEVICE}1 || fail 15
870 # Get the faulty vdev name.
871 local VDEV_FAULTY=`nth_zpool_vdev ${POOL_NAME} sd 1`
873 # Set timeout(0x4) for every nth command.
874 fault_set_sd 4 ${POOL_NTH}
876 # During the failure.
877 pattern_write ${TMP_PATTERN2} 1M 8 ${ZVOL_DEVICE}2 || fail 21
879 # Expect write errors to be logged to 'zpool status'
880 local WRITE_ERRORS=`vdev_write_errors ${POOL_NAME} ${VDEV_FAULTY}`
881 test ${WRITE_ERRORS} -gt 0 || fail 22
883 local VDEV_STATUS=`vdev_status ${POOL_NAME} ${VDEV_FAULTY}`
884 test "${VDEV_STATUS}" = "UNAVAIL" || fail 23
886 # Clear the error and remove it from /dev/.
888 rm -f /dev/${VDEV_FAULTY}[0-9]
890 # Verify the first two patterns and write out the third.
891 pattern_write ${TMP_PATTERN3} 1M 8 ${ZVOL_DEVICE}3 || fail 31
892 pattern_verify ${TMP_PATTERN1} 1M 8 ${ZVOL_DEVICE}1 || fail 32
893 pattern_verify ${TMP_PATTERN2} 1M 8 ${ZVOL_DEVICE}2 || fail 33
894 pattern_verify ${TMP_PATTERN3} 1M 8 ${ZVOL_DEVICE}3 || fail 34
896 # Bring the device back online by rescanning for it. It must appear
897 # in lsscsi and be available to dd before allowing ZFS to bring it
898 # online. This is not required but provides additional sanity.
899 while [ ${RESCAN} -eq 1 ]; do
901 wait_udev /dev/${VDEV_FAULTY} 30
903 if [ `${LSSCSI} | grep -c "/dev/${VDEV_FAULTY}"` -eq 0 ]; then
907 dd if=/dev/${VDEV_FAULTY} of=/dev/null bs=8M count=1 &>/dev/null
908 if [ $? -ne 0 ]; then
915 # Bring the device back online. We expect it to be automatically
916 # resilvered without error and we should see minimally the zfs.io,
917 # zfs.statechange (VDEV_STATE_HEALTHY (0x7)), and zfs.resilver.*
919 ${ZPOOL} online ${POOL_NAME} ${VDEV_FAULTY}1 || fail 51
921 test `zpool_event "zfs.io" "zio_err"` = "0x5" || fail 52
922 test `zpool_event "zfs.statechange" "vdev_state"` = "0x7" || fail 53
923 test `zpool_event "zfs.resilver.start" "ena"` != "" || fail 54
924 test `zpool_event "zfs.resilver.finish" "ena"` != "" || fail 55
925 test `zpool_scan_errors ${POOL_NAME}` -eq 0 || fail 56
927 local VDEV_STATUS=`vdev_status ${POOL_NAME} ${VDEV_FAULTY}`
928 test "${VDEV_STATUS}" = "ONLINE" || fail 57
930 # Verify the known pattern.
931 pattern_verify ${TMP_PATTERN1} 1M 8 ${ZVOL_DEVICE}1 || fail 61
932 pattern_verify ${TMP_PATTERN2} 1M 8 ${ZVOL_DEVICE}2 || fail 62
933 pattern_verify ${TMP_PATTERN3} 1M 8 ${ZVOL_DEVICE}3 || fail 63
934 pattern_remove ${TMP_PATTERN1} || fail 64
935 pattern_remove ${TMP_PATTERN2} || fail 65
936 pattern_remove ${TMP_PATTERN3} || fail 66
938 test_cleanup ${POOL_NAME} ${POOL_CONFIG} ${ZVOL_NAME} ${TMP_CACHE}
943 skip_nonewline # Skip non-redundant config
944 test_write_timeout_hard tank scsi_debug-raid10 1 -50
945 test_write_timeout_hard tank scsi_debug-raidz 1 -50
946 test_write_timeout_hard tank scsi_debug-raidz2 1 -50
947 test_write_timeout_hard tank scsi_debug-raidz3 1 -50
950 run_test 9 "hard write timeout"