common/xfs

   1 #
   2 # XFS specific common functions.
   3 #
   4
   5 _setup_large_xfs_fs()
   6 {
   7         fs_size=$1
   8         local tmp_dir=/tmp/
   9
  10         [ "$LARGE_SCRATCH_DEV" != yes ] && return 0
  11         [ -z "$SCRATCH_DEV_EMPTY_SPACE" ] && SCRATCH_DEV_EMPTY_SPACE=0
  12         [ $SCRATCH_DEV_EMPTY_SPACE -ge $fs_size ] && return 0
  13
  14         # calculate the size of the file we need to allocate.
  15         # Default free space in the FS is 50GB, but you can specify more via
  16         # SCRATCH_DEV_EMPTY_SPACE
  17         file_size=$(($fs_size - 50*1024*1024*1024))
  18         file_size=$(($file_size - $SCRATCH_DEV_EMPTY_SPACE))
  19
  20         # mount the filesystem, create the file, unmount it
  21         _scratch_mount 2>&1 >$tmp_dir/mnt.err
  22         local status=$?
  23         if [ $status -ne 0 ]; then
  24                 echo "mount failed"
  25                 cat $tmp_dir/mnt.err >&2
  26                 rm -f $tmp_dir/mnt.err
  27                 return $status
  28         fi
  29         rm -f $tmp_dir/mnt.err
  30
  31         xfs_io -F -f \
  32                 -c "truncate $file_size" \
  33                 -c "falloc -k 0 $file_size" \
  34                 -c "chattr +d" \
  35                 $SCRATCH_MNT/.use_space 2>&1 > /dev/null
  36         export NUM_SPACE_FILES=1
  37         status=$?
  38         _scratch_unmount
  39         if [ $status -ne 0 ]; then
  40                 echo "large file prealloc failed"
  41                 cat $tmp_dir/mnt.err >&2
  42                 return $status
  43         fi
  44         return 0
  45 }
  46
  47 _scratch_mkfs_xfs_opts()
  48 {
  49         mkfs_opts=$*
  50
  51         # remove metadata related mkfs options if mkfs.xfs doesn't them
  52         if [ -n "$XFS_MKFS_HAS_NO_META_SUPPORT" ]; then
  53                 mkfs_opts=`echo $mkfs_opts | sed "s/-m\s\+\S\+//g"`
  54         fi
  55
  56         _scratch_options mkfs
  57
  58         echo "$MKFS_XFS_PROG $SCRATCH_OPTIONS $mkfs_opts"
  59 }
  60
  61
  62 _scratch_mkfs_xfs_supported()
  63 {
  64         local mkfs_opts=$*
  65
  66         _scratch_options mkfs
  67
  68         $MKFS_XFS_PROG -N $MKFS_OPTIONS $SCRATCH_OPTIONS $mkfs_opts $SCRATCH_DEV
  69         local mkfs_status=$?
  70
  71         # a mkfs failure may be caused by conflicts between $MKFS_OPTIONS and
  72         # $mkfs_opts, try again without $MKFS_OPTIONS
  73         if [ $mkfs_status -ne 0 -a -n "$mkfs_opts" ]; then
  74                 $MKFS_XFS_PROG -N $SCRATCH_OPTIONS $mkfs_opts $SCRATCH_DEV
  75                 mkfs_status=$?
  76         fi
  77         return $mkfs_status
  78 }
  79
  80 _scratch_mkfs_xfs()
  81 {
  82         local mkfs_cmd="`_scratch_mkfs_xfs_opts`"
  83         local mkfs_filter="sed -e '/less than device physical sector/d' \
  84                                -e '/switching to logical sector/d'"
  85         local tmp=`mktemp -u`
  86         local mkfs_status
  87
  88         _scratch_do_mkfs "$mkfs_cmd" "$mkfs_filter" $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
  89         mkfs_status=$?
  90
  91
  92         if [ $mkfs_status -eq 0 -a "$LARGE_SCRATCH_DEV" = yes ]; then
  93                 # manually parse the mkfs output to get the fs size in bytes
  94                 local fs_size
  95                 fs_size=`cat $tmp.mkfsstd | perl -ne '
  96                         if (/^data\s+=\s+bsize=(\d+)\s+blocks=(\d+)/) {
  97                                 my $size = $1 * $2;
  98                                 print STDOUT "$size\n";
  99                         }'`
 100                 _setup_large_xfs_fs $fs_size
 101                 mkfs_status=$?
 102         fi
 103
 104         # output mkfs stdout and stderr
 105         cat $tmp.mkfsstd
 106         cat $tmp.mkfserr >&2
 107         rm -f $tmp.mkfserr $tmp.mkfsstd
 108
 109         return $mkfs_status
 110 }
 111
 112 # xfs_check script is planned to be deprecated. But, we want to
 113 # be able to invoke "xfs_check" behavior in xfstests in order to
 114 # maintain the current verification levels.
 115 _xfs_check()
 116 {
 117         OPTS=" "
 118         DBOPTS=" "
 119         USAGE="Usage: xfs_check [-fsvV] [-l logdev] [-i ino]... [-b bno]... special"
 120
 121         while getopts "b:fi:l:stvV" c; do
 122                 case $c in
 123                         s) OPTS=$OPTS"-s ";;
 124                         t) OPTS=$OPTS"-t ";;
 125                         v) OPTS=$OPTS"-v ";;
 126                         i) OPTS=$OPTS"-i "$OPTARG" ";;
 127                         b) OPTS=$OPTS"-b "$OPTARG" ";;
 128                         f) DBOPTS=$DBOPTS" -f";;
 129                         l) DBOPTS=$DBOPTS" -l "$OPTARG" ";;
 130                         V) $XFS_DB_PROG -p xfs_check -V
 131                            return $?
 132                            ;;
 133                 esac
 134         done
 135         set -- extra $@
 136         shift $OPTIND
 137         case $# in
 138                 1) ${XFS_DB_PROG}${DBOPTS} -F -i -p xfs_check -c "check$OPTS" $1
 139                    status=$?
 140                    ;;
 141                 2) echo $USAGE 1>&1
 142                    status=2
 143                    ;;
 144         esac
 145         return $status
 146 }
 147
 148 _scratch_xfs_db_options()
 149 {
 150         SCRATCH_OPTIONS=""
 151         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 152                 SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 153         echo $SCRATCH_OPTIONS $* $SCRATCH_DEV
 154 }
 155
 156 _scratch_xfs_db()
 157 {
 158         $XFS_DB_PROG "$@" $(_scratch_xfs_db_options)
 159 }
 160
 161 _scratch_xfs_logprint()
 162 {
 163         SCRATCH_OPTIONS=""
 164         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 165                 SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 166         $XFS_LOGPRINT_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
 167 }
 168
 169 _test_xfs_logprint()
 170 {
 171         TEST_OPTIONS=""
 172         [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
 173                 TEST_OPTIONS="-l$TEST_LOGDEV"
 174         $XFS_LOGPRINT_PROG $TEST_OPTIONS $* $TEST_DEV
 175 }
 176
 177 _scratch_xfs_check()
 178 {
 179         SCRATCH_OPTIONS=""
 180         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 181                 SCRATCH_OPTIONS="-l $SCRATCH_LOGDEV"
 182         [ "$LARGE_SCRATCH_DEV" = yes ] && \
 183                 SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
 184         _xfs_check $SCRATCH_OPTIONS $* $SCRATCH_DEV
 185 }
 186
 187 _scratch_xfs_repair()
 188 {
 189         SCRATCH_OPTIONS=""
 190         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 191                 SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
 192         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
 193                 SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -r$SCRATCH_RTDEV"
 194         [ "$LARGE_SCRATCH_DEV" = yes ] && SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
 195         $XFS_REPAIR_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
 196 }
 197
 198 # this test requires the projid32bit feature to be available in mkfs.xfs.
 199 #
 200 _require_projid32bit()
 201 {
 202        _scratch_mkfs_xfs_supported -i projid32bit=1 >/dev/null 2>&1 \
 203            || _notrun "mkfs.xfs doesn't have projid32bit feature"
 204 }
 205
 206 _require_projid16bit()
 207 {
 208         _scratch_mkfs_xfs_supported -i projid32bit=0 >/dev/null 2>&1 \
 209            || _notrun "16 bit project IDs not supported on $SCRATCH_DEV"
 210 }
 211
 212 # this test requires the crc feature to be available in mkfs.xfs
 213 #
 214 _require_xfs_mkfs_crc()
 215 {
 216         _scratch_mkfs_xfs_supported -m crc=1 >/dev/null 2>&1 \
 217            || _notrun "mkfs.xfs doesn't have crc feature"
 218 }
 219
 220 # this test requires the xfs kernel support crc feature
 221 #
 222 _require_xfs_crc()
 223 {
 224         _scratch_mkfs_xfs -m crc=1 >/dev/null 2>&1
 225         _scratch_mount >/dev/null 2>&1 \
 226            || _notrun "Kernel doesn't support crc feature"
 227         _scratch_unmount
 228 }
 229
 230 # this test requires the xfs kernel support crc feature on scratch device
 231 #
 232 _require_scratch_xfs_crc()
 233 {
 234         _scratch_mkfs_xfs >/dev/null 2>&1
 235         _scratch_mount >/dev/null 2>&1 \
 236            || _notrun "Kernel doesn't support crc feature"
 237         xfs_info $SCRATCH_MNT | grep -q 'crc=1' || _notrun "crc feature not supported by this filesystem"
 238         _scratch_unmount
 239 }
 240
 241 # this test requires the finobt feature to be available in mkfs.xfs
 242 #
 243 _require_xfs_mkfs_finobt()
 244 {
 245         _scratch_mkfs_xfs_supported -m crc=1,finobt=1 >/dev/null 2>&1 \
 246            || _notrun "mkfs.xfs doesn't have finobt feature"
 247 }
 248
 249 # this test requires the xfs kernel support finobt feature
 250 #
 251 _require_xfs_finobt()
 252 {
 253         _scratch_mkfs_xfs -m crc=1,finobt=1 >/dev/null 2>&1
 254         _scratch_mount >/dev/null 2>&1 \
 255            || _notrun "Kernel doesn't support finobt feature"
 256         _scratch_unmount
 257 }
 258
 259 # this test requires xfs sysfs attribute support
 260 #
 261 _require_xfs_sysfs()
 262 {
 263         attr=$1
 264         sysfsdir=/sys/fs/xfs
 265
 266         if [ ! -e $sysfsdir ]; then
 267                 _notrun "no kernel support for XFS sysfs attributes"
 268         fi
 269
 270         if [ ! -z $1 ] && [ ! -e $sysfsdir/$attr ]; then
 271                 _notrun "sysfs attribute '$attr' is not supported"
 272         fi
 273 }
 274
 275 # this test requires the xfs sparse inode feature
 276 #
 277 _require_xfs_sparse_inodes()
 278 {
 279         _scratch_mkfs_xfs_supported -m crc=1 -i sparse > /dev/null 2>&1 \
 280                 || _notrun "mkfs.xfs does not support sparse inodes"
 281         _scratch_mkfs_xfs -m crc=1 -i sparse > /dev/null 2>&1
 282         _scratch_mount >/dev/null 2>&1 \
 283                 || _notrun "kernel does not support sparse inodes"
 284         _scratch_unmount
 285 }
 286
 287 # check that xfs_db supports a specific command
 288 _require_xfs_db_command()
 289 {
 290         if [ $# -ne 1 ]; then
 291                 echo "Usage: _require_xfs_db_command command" 1>&2
 292                 exit 1
 293         fi
 294         command=$1
 295
 296         _scratch_xfs_db -x -c "help" | grep $command > /dev/null || \
 297                 _notrun "xfs_db $command support is missing"
 298 }
 299
 300 # run xfs_check and friends on a FS.
 301 _check_xfs_filesystem()
 302 {
 303         if [ $# -ne 3 ]; then
 304                 echo "Usage: _check_xfs_filesystem device <logdev>|none <rtdev>|none" 1>&2
 305                 exit 1
 306         fi
 307
 308         extra_mount_options=""
 309         extra_log_options=""
 310         extra_options=""
 311         device=$1
 312         if [ -f $device ]; then
 313                 extra_options="-f"
 314         fi
 315
 316         if [ "$2" != "none" ]; then
 317                 extra_log_options="-l$2"
 318                 extra_mount_options="-ologdev=$2"
 319         fi
 320
 321         if [ "$3" != "none" ]; then
 322                 extra_rt_options="-r$3"
 323                 extra_mount_options=$extra_mount_options" -ortdev=$3"
 324         fi
 325         extra_mount_options=$extra_mount_options" $MOUNT_OPTIONS"
 326
 327         [ "$FSTYP" != xfs ] && return 0
 328
 329         type=`_fs_type $device`
 330         ok=1
 331
 332         if [ "$type" = "xfs" ]; then
 333                 if [ -n "$TEST_XFS_SCRUB" ] && [ -x "$XFS_SCRUB_PROG" ]; then
 334                         "$XFS_SCRUB_PROG" $scrubflag -v -d -n $device >>$seqres.full
 335                         if [ $? -ne 0 ]; then
 336                                 _log_err "filesystem on $device failed scrub"
 337                                 ok=0
 338                         fi
 339                 fi
 340                 # mounted ...
 341                 mountpoint=`_umount_or_remount_ro $device`
 342         fi
 343
 344         $XFS_LOGPRINT_PROG -t $extra_log_options $device 2>&1 \
 345                 | tee $tmp.logprint | grep -q "<CLEAN>"
 346         if [ $? -ne 0 -a "$HOSTOS" = "Linux" ]; then
 347                 _log_err "_check_xfs_filesystem: filesystem on $device has dirty log"
 348                 echo "*** xfs_logprint -t output ***"   >>$seqres.full
 349                 cat $tmp.logprint                       >>$seqres.full
 350                 echo "*** end xfs_logprint output"      >>$seqres.full
 351
 352                 ok=0
 353         fi
 354
 355         # xfs_check runs out of memory on large files, so even providing the test
 356         # option (-t) to avoid indexing the free space trees doesn't make it pass on
 357         # large filesystems. Avoid it.
 358         if [ "$LARGE_SCRATCH_DEV" != yes ]; then
 359                 _xfs_check $extra_log_options $device 2>&1 |\
 360                         _fix_malloc >$tmp.fs_check
 361         fi
 362         if [ -s $tmp.fs_check ]; then
 363                 _log_err "_check_xfs_filesystem: filesystem on $device is inconsistent (c)"
 364                 echo "*** xfs_check output ***"         >>$seqres.full
 365                 cat $tmp.fs_check                       >>$seqres.full
 366                 echo "*** end xfs_check output"         >>$seqres.full
 367
 368                 ok=0
 369         fi
 370
 371         $XFS_REPAIR_PROG -n $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
 372         if [ $? -ne 0 ]; then
 373                 _log_err "_check_xfs_filesystem: filesystem on $device is inconsistent (r)"
 374                 echo "*** xfs_repair -n output ***"     >>$seqres.full
 375                 cat $tmp.repair | _fix_malloc           >>$seqres.full
 376                 echo "*** end xfs_repair output"        >>$seqres.full
 377
 378                 ok=0
 379         fi
 380         rm -f $tmp.fs_check $tmp.logprint $tmp.repair
 381
 382         # Optionally test the index rebuilding behavior.
 383         if [ -n "$TEST_XFS_REPAIR_REBUILD" ]; then
 384                 $XFS_REPAIR_PROG $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
 385                 if [ $? -ne 0 ]; then
 386                         _log_err "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild)"
 387                         echo "*** xfs_repair output ***"        >>$seqres.full
 388                         cat $tmp.repair | _fix_malloc           >>$seqres.full
 389                         echo "*** end xfs_repair output"        >>$seqres.full
 390
 391                         ok=0
 392                 fi
 393                 rm -f $tmp.repair
 394
 395                 $XFS_REPAIR_PROG -n $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
 396                 if [ $? -ne 0 ]; then
 397                         _log_err "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild-reverify)"
 398                         echo "*** xfs_repair -n output ***"     >>$seqres.full
 399                         cat $tmp.repair | _fix_malloc           >>$seqres.full
 400                         echo "*** end xfs_repair output"        >>$seqres.full
 401
 402                         ok=0
 403                 fi
 404                 rm -f $tmp.repair
 405         fi
 406
 407         if [ $ok -eq 0 ]; then
 408                 echo "*** mount output ***"             >>$seqres.full
 409                 _mount                                  >>$seqres.full
 410                 echo "*** end mount output"             >>$seqres.full
 411         elif [ "$type" = "xfs" ]; then
 412                 _mount_or_remount_rw "$extra_mount_options" $device $mountpoint
 413         fi
 414
 415         if [ $ok -eq 0 ]; then
 416                 status=1
 417                 if [ "$iam" != "check" ]; then
 418                         exit 1
 419                 fi
 420                 return 1
 421         fi
 422
 423         return 0
 424 }
 425
 426 _check_xfs_test_fs()
 427 {
 428         TEST_LOG="none"
 429         TEST_RT="none"
 430         [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
 431                 TEST_LOG="$TEST_LOGDEV"
 432
 433         [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
 434                 TEST_RT="$TEST_RTDEV"
 435
 436         _check_xfs_filesystem $TEST_DEV $TEST_LOG $TEST_RT
 437
 438         # check for ipath consistency
 439         if $XFS_GROWFS_PROG -n $TEST_DIR | grep -q 'inode-paths=1'; then
 440                 # errors go to stderr
 441                 xfs_check_ipaths $TEST_DIR >/dev/null
 442                 xfs_repair_ipaths -n $TEST_DIR >/dev/null
 443         fi
 444 }
 445
 446 _require_xfs_test_rmapbt()
 447 {
 448         _require_test
 449
 450         if [ "$(xfs_info "$TEST_DIR" | grep -c "rmapbt=1")" -ne 1 ]; then
 451                 _notrun "rmapbt not supported by test filesystem type: $FSTYP"
 452         fi
 453 }
 454
 455 _require_xfs_scratch_rmapbt()
 456 {
 457         _require_scratch
 458
 459         _scratch_mkfs > /dev/null
 460         _scratch_mount
 461         if [ "$(xfs_info "$SCRATCH_MNT" | grep -c "rmapbt=1")" -ne 1 ]; then
 462                 _scratch_unmount
 463                 _notrun "rmapbt not supported by scratch filesystem type: $FSTYP"
 464         fi
 465         _scratch_unmount
 466 }
 467
 468 _xfs_bmapx_find()
 469 {
 470         case "$1" in
 471         "attr")
 472                 param="a"
 473                 ;;
 474         "cow")
 475                 param="c"
 476                 ;;
 477         *)
 478                 param="e"
 479                 ;;
 480         esac
 481         shift
 482         file="$1"
 483         shift
 484
 485         $XFS_IO_PROG -c "bmap -${param}lpv" "$file" | grep -c "$@"
 486 }
 487
 488 # Reset all xfs error handling attributes, set them to original
 489 # status.
 490 #
 491 # Only one argument, and it's mandatory:
 492 #  - dev: device name, e.g. $SCRATCH_DEV
 493 #
 494 # Note: this function only works for XFS
 495 _reset_xfs_sysfs_error_handling()
 496 {
 497         local dev=$1
 498
 499         if [ ! -b "$dev" -o "$FSTYP" != "xfs" ]; then
 500                 _fail "Usage: reset_xfs_sysfs_error_handling <device>"
 501         fi
 502
 503         _set_fs_sysfs_attr $dev error/fail_at_unmount 1
 504         echo -n "error/fail_at_unmount="
 505         _get_fs_sysfs_attr $dev error/fail_at_unmount
 506
 507         # Make sure all will be configured to retry forever by default, except
 508         # for ENODEV, which is an unrecoverable error, so it will be configured
 509         # to not retry on error by default.
 510         for e in default EIO ENOSPC; do
 511                 _set_fs_sysfs_attr $dev \
 512                                    error/metadata/${e}/max_retries -1
 513                 echo -n "error/metadata/${e}/max_retries="
 514                 _get_fs_sysfs_attr $dev error/metadata/${e}/max_retries
 515
 516                 _set_fs_sysfs_attr $dev \
 517                                    error/metadata/${e}/retry_timeout_seconds 0
 518                 echo -n "error/metadata/${e}/retry_timeout_seconds="
 519                 _get_fs_sysfs_attr $dev \
 520                                    error/metadata/${e}/retry_timeout_seconds
 521         done
 522 }
 523
 524 # Skip if we are running an older binary without the stricter input checks.
 525 # Make multiple checks to be sure that there is no regression on the one
 526 # selected feature check, which would skew the result.
 527 #
 528 # At first, make a common function that runs the tests and returns
 529 # number of failed cases.
 530 _xfs_mkfs_validation_check()
 531 {
 532         local tmpfile=`mktemp`
 533         local cmd="$MKFS_XFS_PROG -f -N -d file,name=$tmpfile,size=1g"
 534
 535         $cmd -s size=8s >/dev/null 2>&1
 536         local sum=$?
 537
 538         $cmd -l version=2,su=260k >/dev/null 2>&1
 539         sum=`expr $sum + $?`
 540
 541         rm -f $tmpfile
 542         return $sum
 543 }
 544
 545 # Skip the test if all calls passed - mkfs accepts invalid input
 546 _require_xfs_mkfs_validation()
 547 {
 548         _xfs_mkfs_validation_check
 549         if [ "$?" -eq 0 ]; then
 550                 _notrun "Requires newer mkfs with stricter input checks: the oldest supported version of xfsprogs is 4.7."
 551         fi
 552 }
 553
 554 # The opposite of _require_xfs_mkfs_validation.
 555 _require_xfs_mkfs_without_validation()
 556 {
 557         _xfs_mkfs_validation_check
 558         if [ "$?" -ne 0 ]; then
 559                 _notrun "Requires older mkfs without strict input checks: the last supported version of xfsprogs is 4.5."
 560         fi
 561 }
 562
 563 # XFS ability to change UUIDs on V5/CRC filesystems
 564 #
 565 _require_meta_uuid()
 566 {
 567         # This will create a crc fs on $SCRATCH_DEV
 568         _require_xfs_crc
 569
 570         _scratch_xfs_db -x -c "uuid restore" 2>&1 \
 571            | grep -q "invalid UUID\|supported on V5 fs" \
 572            && _notrun "Userspace doesn't support meta_uuid feature"
 573
 574         _scratch_xfs_db -x -c "uuid generate" >/dev/null 2>&1
 575
 576         _scratch_mount >/dev/null 2>&1 \
 577            || _notrun "Kernel doesn't support meta_uuid feature"
 578         _scratch_unmount
 579 }
 580
 581 # this test requires mkfs.xfs have case-insensitive naming support
 582 _require_xfs_mkfs_ciname()
 583 {
 584         _scratch_mkfs_xfs_supported -n version=ci >/dev/null 2>&1 \
 585                 || _notrun "need case-insensitive naming support in mkfs.xfs"
 586 }
 587
 588 # xfs generates WARNINGs on purpose when applications mix buffered/mmap IO with
 589 # direct IO on the same file. This is a helper for _check_dmesg() to filter out
 590 # such warnings.
 591 _filter_xfs_dmesg()
 592 {
 593         local warn1="WARNING:.*fs/xfs/xfs_file\.c:.*xfs_file_dio_aio_write.*"
 594         local warn2="WARNING:.*fs/xfs/xfs_file\.c:.*xfs_file_dio_aio_read.*"
 595         local warn3="WARNING:.*fs/xfs/xfs_file\.c:.*xfs_file_read_iter.*"
 596         local warn4="WARNING:.*fs/xfs/xfs_file\.c:.*xfs_file_aio_read.*"
 597         local warn5="WARNING:.*fs/iomap\.c:.*iomap_dio_rw.*"
 598         local warn6="WARNING:.*fs/xfs/xfs_aops\.c:.*__xfs_get_blocks.*"
 599         local warn7="WARNING:.*fs/iomap\.c:.*iomap_dio_actor.*"
 600         sed -e "s#$warn1#Intentional warnings in xfs_file_dio_aio_write#" \
 601             -e "s#$warn2#Intentional warnings in xfs_file_dio_aio_read#" \
 602             -e "s#$warn3#Intentional warnings in xfs_file_read_iter#" \
 603             -e "s#$warn4#Intentional warnings in xfs_file_aio_read#" \
 604             -e "s#$warn5#Intentional warnings in iomap_dio_rw#" \
 605             -e "s#$warn6#Intentional warnings in __xfs_get_blocks#" \
 606             -e "s#$warn7#Intentional warnings in iomap_dio_actor#"
 607 }