test/fs/fs-test.sh

   1 #!/bin/bash
   2 #
   3 # (C) Copyright 2014 Suriyan Ramasami
   4 #
   5 #  SPDX-License-Identifier:     GPL-2.0+
   6 #
   7
   8 # Invoke this test script from U-Boot base directory as ./test/fs/fs-test.sh
   9 # It currently tests the fs/sb and native commands for ext4 and fat partitions
  10 # Expected results are as follows:
  11 # EXT4 tests:
  12 # fs-test.sb.ext4.out: Summary: PASS: 23 FAIL: 0
  13 # fs-test.ext4.out: Summary: PASS: 23 FAIL: 0
  14 # fs-test.fs.ext4.out: Summary: PASS: 23 FAIL: 0
  15 # FAT tests:
  16 # fs-test.sb.fat.out: Summary: PASS: 23 FAIL: 0
  17 # fs-test.fat.out: Summary: PASS: 20 FAIL: 3
  18 # fs-test.fs.fat.out: Summary: PASS: 20 FAIL: 3
  19 # Total Summary: TOTAL PASS: 132 TOTAL FAIL: 6
  20
  21 # pre-requisite binaries list.
  22 PREREQ_BINS="md5sum mkfs mount umount dd fallocate mkdir"
  23
  24 # All generated output files from this test will be in $OUT_DIR
  25 # Hence everything is sandboxed.
  26 OUT_DIR="sandbox/test/fs"
  27
  28 # Location of generated sandbox u-boot
  29 UBOOT="./sandbox/u-boot"
  30
  31 # Our mount directory will be in the sandbox
  32 MOUNT_DIR="${OUT_DIR}/mnt"
  33
  34 # The file system image we create will have the $IMG prefix.
  35 IMG="${OUT_DIR}/3GB"
  36
  37 # $SMALL_FILE is the name of the 1MB file in the file system image
  38 SMALL_FILE="1MB.file"
  39
  40 # $BIG_FILE is the name of the 2.5GB file in the file system image
  41 BIG_FILE="2.5GB.file"
  42
  43 # $MD5_FILE will have the expected md5s when we do the test
  44 # They shall have a suffix which represents their file system (ext4/fat)
  45 MD5_FILE="${OUT_DIR}/md5s.list"
  46
  47 # $OUT shall be the prefix of the test output. Their suffix will be .out
  48 OUT="${OUT_DIR}/fs-test"
  49
  50 # Full Path of the 1 MB file that shall be created in the fs image.
  51 MB1="${MOUNT_DIR}/${SMALL_FILE}"
  52 GB2p5="${MOUNT_DIR}/${BIG_FILE}"
  53
  54 # ************************
  55 # * Functions start here *
  56 # ************************
  57
  58 # Check if the prereq binaries exist, or exit
  59 function check_prereq() {
  60         for prereq in $PREREQ_BINS; do
  61                 if [ ! -x "`which $prereq`" ]; then
  62                         echo "Missing $prereq binary. Exiting!"
  63                         exit
  64                 fi
  65         done
  66
  67         # We use /dev/urandom to create files. Check if it exists.
  68         if [ ! -c /dev/urandom ]; then
  69                 echo "Missing character special /dev/urandom. Exiting!"
  70                 exit
  71         fi
  72 }
  73
  74 # If 1st param is "clean", then clean out the generated files and exit
  75 function check_clean() {
  76         if [ "$1" = "clean" ]; then
  77                 rm -rf "$OUT_DIR"
  78                 echo "Cleaned up generated files. Exiting"
  79                 exit
  80         fi
  81 }
  82
  83 # Generate sandbox U-Boot - gleaned from /test/dm/test-dm.sh
  84 function compile_sandbox() {
  85         unset CROSS_COMPILE
  86         NUM_CPUS=$(cat /proc/cpuinfo |grep -c processor)
  87         make O=sandbox sandbox_config
  88         make O=sandbox -s -j${NUM_CPUS}
  89
  90         # Check if U-Boot exists
  91         if [ ! -x "$UBOOT" ]; then
  92                 echo "$UBOOT does not exist or is not executable"
  93                 echo "Build error?"
  94                 echo "Please run this script as ./test/fs/`basename $0`"
  95                 exit
  96         fi
  97 }
  98
  99 # Clean out all generated files other than the file system images
 100 # We save time by not deleting and recreating the file system images
 101 function prepare_env() {
 102         rm -f ${MD5_FILE}.* ${OUT}.*
 103         mkdir -p ${OUT_DIR}
 104 }
 105
 106 # 1st parameter is the name of the image file to be created
 107 # 2nd parameter is the filesystem - fat ext4 etc
 108 # -F cant be used with fat as it means something else.
 109 function create_image() {
 110         # Create image if not already present - saves time, while debugging
 111         if [ "$2" = "ext4" ]; then
 112                 MKFS_OPTION="-F"
 113         else
 114                 MKFS_OPTION=""
 115         fi
 116         if [ ! -f "$1" ]; then
 117                 fallocate -l 3G "$1" &> /dev/null
 118                 if [ $? -ne 0 ]; then
 119                         echo fallocate failed - using dd instead
 120                         dd if=/dev/zero of=$1 bs=1024 count=$((3 * 1024 * 1024))
 121                         if [ $? -ne 0 ]; then
 122                                 echo Could not create empty disk image
 123                                 exit $?
 124                         fi
 125                 fi
 126                 mkfs -t "$2" $MKFS_OPTION "$1" &> /dev/null
 127                 if [ $? -ne 0 -a "$2" = "fat" ]; then
 128                         # If we fail and we did fat, try vfat.
 129                         mkfs -t vfat $MKFS_OPTION "$1" &> /dev/null
 130                 fi
 131                 if [ $? -ne 0 ]; then
 132                         echo Could not create filesystem
 133                         exit $?
 134                 fi
 135         fi
 136 }
 137
 138 # 1st parameter is image file
 139 # 2nd parameter is file system type - fat/ext4
 140 # 3rd parameter is name of small file
 141 # 4th parameter is name of big file
 142 # 5th parameter is fs/nonfs/sb - to dictate generic fs commands or
 143 # otherwise or sb hostfs
 144 # 6th parameter is the directory path for the files. Its "" for generic
 145 # fs and ext4/fat and full patch for sb hostfs
 146 # UBOOT is set in env
 147 function test_image() {
 148         addr="0x01000008"
 149         length="0x00100000"
 150
 151         case "$2" in
 152                 fat)
 153                 FPATH=""
 154                 PREFIX="fat"
 155                 WRITE="write"
 156                 ;;
 157
 158                 ext4)
 159                 # ext4 needs absolute path
 160                 FPATH="/"
 161                 PREFIX="ext4"
 162                 WRITE="write"
 163                 ;;
 164
 165                 *)
 166                 echo "Unhandled filesystem $2. Exiting!"
 167                 exit
 168                 ;;
 169         esac
 170
 171         case "$5" in
 172                 fs)
 173                 PREFIX=""
 174                 WRITE="save"
 175                 SUFFIX=" 0:0"
 176                 ;;
 177
 178                 nonfs)
 179                 SUFFIX=" 0:0"
 180                 ;;
 181
 182                 sb)
 183                 PREFIX="sb "
 184                 WRITE="save"
 185                 SUFFIX="fs -"
 186                 ;;
 187
 188                 *)
 189                 echo "Unhandled mode $5. Exiting!"
 190                 exit
 191                 ;;
 192
 193         esac
 194
 195         # sb always uses full path to mointpoint, irrespective of filesystem
 196         if [ "$5" = "sb" ]; then
 197                 FPATH=${6}/
 198         fi
 199
 200         FILE_WRITE=${3}.w
 201         FILE_SMALL=$3
 202         FILE_BIG=$4
 203
 204         # In u-boot commands, <interface> stands for host or hostfs
 205         # hostfs maps to the host fs.
 206         # host maps to the "sb bind" that we do
 207
 208         $UBOOT << EOF
 209 sb=$5
 210 setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
 211 run bind
 212 # Test Case 1 - ls
 213 ${PREFIX}ls host${SUFFIX} $6
 214 #
 215 # We want ${PREFIX}size host 0:0 $3 for host commands and
 216 # sb size hostfs - $3 for hostfs commands.
 217 # 1MB is 0x0010 0000
 218 # Test Case 2 - size of small file
 219 ${PREFIX}size host${SUFFIX} ${FPATH}$FILE_SMALL
 220 printenv filesize
 221 setenv filesize
 222
 223 # 2.5GB (1024*1024*2500) is 0x9C40 0000
 224 # Test Case 3 - size of big file
 225 ${PREFIX}size host${SUFFIX} ${FPATH}$FILE_BIG
 226 printenv filesize
 227 setenv filesize
 228
 229 # Notes about load operation
 230 # If I use 0x01000000 I get DMA misaligned error message
 231 # Last two parameters are size and offset.
 232
 233 # Test Case 4a - Read full 1MB of small file
 234 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_SMALL
 235 printenv filesize
 236 # Test Case 4b - Read full 1MB of small file
 237 md5sum $addr \$filesize
 238 setenv filesize
 239
 240 # Test Case 5a - First 1MB of big file
 241 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x0
 242 printenv filesize
 243 # Test Case 5b - First 1MB of big file
 244 md5sum $addr \$filesize
 245 setenv filesize
 246
 247 # fails for ext as no offset support
 248 # Test Case 6a - Last 1MB of big file
 249 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x9C300000
 250 printenv filesize
 251 # Test Case 6b - Last 1MB of big file
 252 md5sum $addr \$filesize
 253 setenv filesize
 254
 255 # fails for ext as no offset support
 256 # Test Case 7a - One from the last 1MB chunk of 2GB
 257 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x7FF00000
 258 printenv filesize
 259 # Test Case 7b - One from the last 1MB chunk of 2GB
 260 md5sum $addr \$filesize
 261 setenv filesize
 262
 263 # fails for ext as no offset support
 264 # Test Case 8a - One from the start 1MB chunk from 2GB
 265 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x80000000
 266 printenv filesize
 267 # Test Case 8b - One from the start 1MB chunk from 2GB
 268 md5sum $addr \$filesize
 269 setenv filesize
 270
 271 # fails for ext as no offset support
 272 # Test Case 9a - One 1MB chunk crossing the 2GB boundary
 273 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x7FF80000
 274 printenv filesize
 275 # Test Case 9b - One 1MB chunk crossing the 2GB boundary
 276 md5sum $addr \$filesize
 277 setenv filesize
 278
 279 # Generic failure case
 280 # Test Case 10 - 2MB chunk from the last 1MB of big file
 281 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG 0x00200000 0x9C300000
 282 printenv filesize
 283 #
 284
 285 # Read 1MB from small file
 286 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_SMALL
 287 # Write it back to test the writes
 288 # Test Case 11a - Check that the write succeeded
 289 ${PREFIX}${WRITE} host${SUFFIX} $addr ${FPATH}$FILE_WRITE \$filesize
 290 mw.b $addr 00 100
 291 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_WRITE
 292 # Test Case 11b - Check md5 of written to is same as the one read from
 293 md5sum $addr \$filesize
 294 setenv filesize
 295 #
 296
 297 # Next test case checks writing a file whose dirent
 298 # is the first in the block, which is always true for "."
 299 # The write should fail, but the lookup should work
 300 # Test Case 12 - Check directory traversal
 301 ${PREFIX}${WRITE} host${SUFFIX} $addr ${FPATH}. 0x10
 302
 303 # Read 1MB from small file
 304 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_SMALL
 305 # Write it via "same directory", i.e. "." dirent
 306 # Test Case 13a - Check directory traversal
 307 ${PREFIX}${WRITE} host${SUFFIX} $addr ${FPATH}./${FILE_WRITE}2 \$filesize
 308 mw.b $addr 00 100
 309 ${PREFIX}load host${SUFFIX} $addr ${FPATH}./${FILE_WRITE}2
 310 # Test Case 13b - Check md5 of written to is same as the one read from
 311 md5sum $addr \$filesize
 312 setenv filesize
 313 mw.b $addr 00 100
 314 ${PREFIX}load host${SUFFIX} $addr ${FPATH}${FILE_WRITE}2
 315 # Test Case 13c - Check md5 of written to is same as the one read from
 316 md5sum $addr \$filesize
 317 setenv filesize
 318 #
 319 reset
 320
 321 EOF
 322 }
 323
 324 # 1st argument is the name of the image file.
 325 # 2nd argument is the file where we generate the md5s of the files
 326 # generated with the appropriate start and length that we use to test.
 327 # It creates the necessary files in the image to test.
 328 # $GB2p5 is the path of the big file (2.5 GB)
 329 # $MB1 is the path of the small file (1 MB)
 330 # $MOUNT_DIR is the path we can use to mount the image file.
 331 function create_files() {
 332         # Mount the image so we can populate it.
 333         mkdir -p "$MOUNT_DIR"
 334         sudo mount -o loop,rw "$1" "$MOUNT_DIR"
 335
 336         # Create big file in this image.
 337         # Note that we work only on the start 1MB, couple MBs in the 2GB range
 338         # and the last 1 MB of the huge 2.5GB file.
 339         # So, just put random values only in those areas.
 340         if [ ! -f "${GB2p5}" ]; then
 341                 sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 \
 342                         &> /dev/null
 343                 sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=2 seek=2047 \
 344                         &> /dev/null
 345                 sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 seek=2499 \
 346                         &> /dev/null
 347         fi
 348
 349         # Create a small file in this image.
 350         if [ ! -f "${MB1}" ]; then
 351                 sudo dd if=/dev/urandom of="${MB1}" bs=1M count=1 \
 352                         &> /dev/null
 353         fi
 354
 355         # Delete the small file copies which possibly are written as part of a
 356         # previous test.
 357         sudo rm -f "${MB1}.w"
 358         sudo rm -f "${MB1}.w2"
 359
 360         # Generate the md5sums of reads that we will test against small file
 361         dd if="${MB1}" bs=1M skip=0 count=1 2> /dev/null | md5sum > "$2"
 362
 363         # Generate the md5sums of reads that we will test against big file
 364         # One from beginning of file.
 365         dd if="${GB2p5}" bs=1M skip=0 count=1 \
 366                 2> /dev/null | md5sum >> "$2"
 367
 368         # One from end of file.
 369         dd if="${GB2p5}" bs=1M skip=2499 count=1 \
 370                 2> /dev/null | md5sum >> "$2"
 371
 372         # One from the last 1MB chunk of 2GB
 373         dd if="${GB2p5}" bs=1M skip=2047 count=1 \
 374                 2> /dev/null | md5sum >> "$2"
 375
 376         # One from the start 1MB chunk from 2GB
 377         dd if="${GB2p5}" bs=1M skip=2048 count=1 \
 378                 2> /dev/null | md5sum >> "$2"
 379
 380         # One 1MB chunk crossing the 2GB boundary
 381         dd if="${GB2p5}" bs=512K skip=4095 count=2 \
 382                 2> /dev/null | md5sum >> "$2"
 383
 384         sync
 385         sudo umount "$MOUNT_DIR"
 386         rmdir "$MOUNT_DIR"
 387 }
 388
 389 # 1st parameter is the text to print
 390 # if $? is 0 its a pass, else a fail
 391 # As a side effect it shall update env variable PASS and FAIL
 392 function pass_fail() {
 393         if [ $? -eq 0 ]; then
 394                 echo pass - "$1"
 395                 PASS=$((PASS + 1))
 396         else
 397                 echo FAIL - "$1"
 398                 FAIL=$((FAIL + 1))
 399         fi
 400 }
 401
 402 # 1st parameter is the string which leads to an md5 generation
 403 # 2nd parameter is the file we grep, for that string
 404 # 3rd parameter is the name of the file which has md5s in it
 405 # 4th parameter is the line # in the md5 file that we match it against
 406 # This function checks if the md5 of the file in the sandbox matches
 407 # that calculated while generating the file
 408 # 5th parameter is the string to print with the result
 409 check_md5() {
 410         # md5sum in u-boot has output of form:
 411         # md5 for 01000008 ... 01100007 ==> <md5>
 412         # the 7th field is the actual md5
 413         md5_src=`grep -A2 "$1" "$2" | grep "md5 for" | tr -d '\r'`
 414         md5_src=($md5_src)
 415         md5_src=${md5_src[6]}
 416
 417         # The md5 list, each line is of the form:
 418         # - <md5>
 419         # the 2nd field is the actual md5
 420         md5_dst=`sed -n $4p $3`
 421         md5_dst=($md5_dst)
 422         md5_dst=${md5_dst[0]}
 423
 424         # For a pass they should match.
 425         [ "$md5_src" = "$md5_dst" ]
 426         pass_fail "$5"
 427 }
 428
 429 # 1st parameter is the name of the output file to check
 430 # 2nd parameter is the name of the file containing the md5 expected
 431 # 3rd parameter is the name of the small file
 432 # 4th parameter is the name of the big file
 433 # 5th paramter is the name of the written file
 434 # This function checks the output file for correct results.
 435 function check_results() {
 436         echo "** Start $1"
 437
 438         PASS=0
 439         FAIL=0
 440
 441         # Check if the ls is showing correct results for 2.5 gb file
 442         grep -A6 "Test Case 1 " "$1" | egrep -iq "2621440000 *$4"
 443         pass_fail "TC1: ls of $4"
 444
 445         # Check if the ls is showing correct results for 1 mb file
 446         grep -A6 "Test Case 1 " "$1" | egrep -iq "1048576 *$3"
 447         pass_fail "TC1: ls of $3"
 448
 449         # Check size command on 1MB.file
 450         egrep -A3 "Test Case 2 " "$1" | grep -q "filesize=100000"
 451         pass_fail "TC2: size of $3"
 452
 453         # Check size command on 2.5GB.file
 454         egrep -A3 "Test Case 3 " "$1" | grep -q "filesize=9c400000"
 455         pass_fail "TC3: size of $4"
 456
 457         # Check read full mb of 1MB.file
 458         grep -A4 "Test Case 4a " "$1" | grep -q "filesize=100000"
 459         pass_fail "TC4: load of $3 size"
 460         check_md5 "Test Case 4b " "$1" "$2" 1 "TC4: load from $3"
 461
 462         # Check first mb of 2.5GB.file
 463         grep -A4 "Test Case 5a " "$1" | grep -q "filesize=100000"
 464         pass_fail "TC5: load of 1st MB from $4 size"
 465         check_md5 "Test Case 5b " "$1" "$2" 2 "TC5: load of 1st MB from $4"
 466
 467         # Check last mb of 2.5GB.file
 468         grep -A4 "Test Case 6a " "$1" | grep -q "filesize=100000"
 469         pass_fail "TC6: load of last MB from $4 size"
 470         check_md5 "Test Case 6b " "$1" "$2" 3 "TC6: load of last MB from $4"
 471
 472         # Check last 1mb chunk of 2gb from 2.5GB file
 473         grep -A4 "Test Case 7a " "$1" | grep -q "filesize=100000"
 474         pass_fail "TC7: load of last 1mb chunk of 2GB from $4 size"
 475         check_md5 "Test Case 7b " "$1" "$2" 4 \
 476                 "TC7: load of last 1mb chunk of 2GB from $4"
 477
 478         # Check first 1mb chunk after 2gb from 2.5GB file
 479         grep -A4 "Test Case 8a " "$1" | grep -q "filesize=100000"
 480         pass_fail "TC8: load 1st MB chunk after 2GB from $4 size"
 481         check_md5 "Test Case 8b " "$1" "$2" 5 \
 482                 "TC8: load 1st MB chunk after 2GB from $4"
 483
 484         # Check 1mb chunk crossing the 2gb boundary from 2.5GB file
 485         grep -A4 "Test Case 9a " "$1" | grep -q "filesize=100000"
 486         pass_fail "TC9: load 1MB chunk crossing 2GB boundary from $4 size"
 487         check_md5 "Test Case 9b " "$1" "$2" 6 \
 488                 "TC9: load 1MB chunk crossing 2GB boundary from $4"
 489
 490         # Check 2mb chunk from the last 1MB of 2.5GB file loads 1MB
 491         grep -A5 "Test Case 10 " "$1" | grep -q "filesize=100000"
 492         pass_fail "TC10: load 2MB from the last 1MB of $4 loads 1MB"
 493
 494         # Check 1mb chunk write
 495         grep -A2 "Test Case 11a " "$1" | grep -q '1048576 bytes written'
 496         pass_fail "TC11: 1MB write to $3.w - write succeeded"
 497         check_md5 "Test Case 11b " "$1" "$2" 1 \
 498                 "TC11: 1MB write to $3.w - content verified"
 499
 500         # Check lookup of 'dot' directory
 501         grep -A4 "Test Case 12 " "$1" | grep -q 'Unable to write file'
 502         pass_fail "TC12: 1MB write to . - write denied"
 503
 504         # Check directory traversal
 505         grep -A2 "Test Case 13a " "$1" | grep -q '1048576 bytes written'
 506         pass_fail "TC13: 1MB write to ./$3.w2 - write succeeded"
 507         check_md5 "Test Case 13b " "$1" "$2" 1 \
 508                 "TC13: 1MB read from ./$3.w2 - content verified"
 509         check_md5 "Test Case 13c " "$1" "$2" 1 \
 510                 "TC13: 1MB read from $3.w2 - content verified"
 511
 512         echo "** End $1"
 513 }
 514
 515 # Takes in one parameter which is "fs" or "nonfs", which then dictates
 516 # if a fs test (size/load/save) or a nonfs test (fatread/extread) needs to
 517 # be performed.
 518 function test_fs_nonfs() {
 519         echo "Creating files in $fs image if not already present."
 520         create_files $IMAGE $MD5_FILE_FS
 521
 522         OUT_FILE="${OUT}.$1.${fs}.out"
 523         test_image $IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
 524                 > ${OUT_FILE} 2>&1
 525         # strip out noise from fs code
 526         grep -v -e "File System is consistent\|update journal finished" \
 527                 -e "reading .*\.file\|writing .*\.file.w" \
 528                 < ${OUT_FILE} > ${OUT_FILE}_clean
 529         check_results ${OUT_FILE}_clean $MD5_FILE_FS $SMALL_FILE \
 530                 $BIG_FILE
 531         TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
 532         TOTAL_PASS=$((TOTAL_PASS + PASS))
 533         echo "Summary: PASS: $PASS FAIL: $FAIL"
 534         echo "--------------------------------------------"
 535 }
 536
 537 # ********************
 538 # * End of functions *
 539 # ********************
 540
 541 check_clean "$1"
 542 check_prereq
 543 compile_sandbox
 544 prepare_env
 545
 546 # Track TOTAL_FAIL and TOTAL_PASS
 547 TOTAL_FAIL=0
 548 TOTAL_PASS=0
 549
 550 # In each loop, for a given file system image, we test both the
 551 # fs command, like load/size/write, the file system specific command
 552 # like: ext4load/ext4size/ext4write and the sb load/ls/save commands.
 553 for fs in ext4 fat; do
 554
 555         echo "Creating $fs image if not already present."
 556         IMAGE=${IMG}.${fs}.img
 557         MD5_FILE_FS="${MD5_FILE}.${fs}"
 558         create_image $IMAGE $fs
 559
 560         # sb commands test
 561         echo "Creating files in $fs image if not already present."
 562         create_files $IMAGE $MD5_FILE_FS
 563
 564         # Lets mount the image and test sb hostfs commands
 565         mkdir -p "$MOUNT_DIR"
 566         if [ "$fs" = "fat" ]; then
 567                 uid="uid=`id -u`"
 568         else
 569                 uid=""
 570         fi
 571         sudo mount -o loop,rw,$uid "$IMAGE" "$MOUNT_DIR"
 572         sudo chmod 777 "$MOUNT_DIR"
 573
 574         OUT_FILE="${OUT}.sb.${fs}.out"
 575         test_image $IMAGE $fs $SMALL_FILE $BIG_FILE sb `pwd`/$MOUNT_DIR \
 576                 > ${OUT_FILE} 2>&1
 577         sudo umount "$MOUNT_DIR"
 578         rmdir "$MOUNT_DIR"
 579
 580         check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE
 581         TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
 582         TOTAL_PASS=$((TOTAL_PASS + PASS))
 583         echo "Summary: PASS: $PASS FAIL: $FAIL"
 584         echo "--------------------------------------------"
 585
 586         test_fs_nonfs nonfs
 587         test_fs_nonfs fs
 588 done
 589
 590 echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
 591 echo "--------------------------------------------"
 592 if [ $TOTAL_FAIL -eq 0 ]; then
 593         echo "PASSED"
 594         exit 0
 595 else
 596         echo "FAILED"
 597         exit 1
 598 fi