sandbox: script for testing sandbox/ext4/fat/fs commands
authorSuriyan Ramasami <suriyan.r@gmail.com>
Mon, 17 Nov 2014 22:39:39 +0000 (14:39 -0800)
committerTom Rini <trini@ti.com>
Sun, 23 Nov 2014 11:49:05 +0000 (06:49 -0500)
Test size/read/write commands in a sandbox environment.

Signed-off-by: Suriyan Ramasami <suriyan.r@gmail.com>
Acked-by: Simon Glass <sjg@chromium.org>
test/fs/fs-test.sh [new file with mode: 0755]

diff --git a/test/fs/fs-test.sh b/test/fs/fs-test.sh
new file mode 100755 (executable)
index 0000000..a4fb055
--- /dev/null
@@ -0,0 +1,561 @@
+#!/bin/bash
+#
+# (C) Copyright 2014 Suriyan Ramasami
+#
+#  SPDX-License-Identifier:    GPL-2.0+
+#
+
+# Invoke this test script from U-Boot base directory as ./test/fs/fs-test.sh
+# It currently tests the fs/sb and native commands for ext4 and fat partitions
+# Expected results are as follows:
+# EXT4 tests:
+# fs-test.sb.ext4.out: Summary: PASS: 17 FAIL: 2
+# fs-test.ext4.out: Summary: PASS: 11 FAIL: 8
+# fs-test.fs.ext4.out: Summary: PASS: 11 FAIL: 8
+# FAT tests:
+# fs-test.sb.fat.out: Summary: PASS: 17 FAIL: 2
+# fs-test.fat.out: Summary: PASS: 19 FAIL: 0
+# fs-test.fs.fat.out: Summary: PASS: 19 FAIL: 0
+# Total Summary: TOTAL PASS: 94 TOTAL FAIL: 20
+
+# pre-requisite binaries list.
+PREREQ_BINS="md5sum mkfs mount umount dd fallocate mkdir"
+
+# All generated output files from this test will be in $OUT_DIR
+# Hence everything is sandboxed.
+OUT_DIR="sandbox/test/fs"
+
+# Location of generated sandbox u-boot
+UBOOT="./sandbox/u-boot"
+
+# Our mount directory will be in the sandbox
+MOUNT_DIR="${OUT_DIR}/mnt"
+
+# The file system image we create will have the $IMG prefix.
+IMG="${OUT_DIR}/3GB"
+
+# $SMALL_FILE is the name of the 1MB file in the file system image
+SMALL_FILE="1MB.file"
+
+# $BIG_FILE is the name of the 2.5GB file in the file system image
+BIG_FILE="2.5GB.file"
+
+# $MD5_FILE will have the expected md5s when we do the test
+# They shall have a suffix which represents their file system (ext4/fat)
+MD5_FILE="${OUT_DIR}/md5s.list"
+
+# $OUT shall be the prefix of the test output. Their suffix will be .out
+OUT="${OUT_DIR}/fs-test"
+
+# Full Path of the 1 MB file that shall be created in the fs image.
+MB1="${MOUNT_DIR}/${SMALL_FILE}"
+GB2p5="${MOUNT_DIR}/${BIG_FILE}"
+
+# ************************
+# * Functions start here *
+# ************************
+
+# Check if the prereq binaries exist, or exit
+function check_prereq() {
+       for prereq in $PREREQ_BINS; do
+               if [ ! -x `which $prereq` ]; then
+                       echo "Missing $prereq binary. Exiting!"
+                       exit
+               fi
+       done
+
+       # We use /dev/urandom to create files. Check if it exists.
+       if [ ! -c /dev/urandom ]; then
+               echo "Missing character special /dev/urandom. Exiting!"
+               exit
+       fi
+}
+
+# If 1st param is "clean", then clean out the generated files and exit
+function check_clean() {
+       if [ "$1" = "clean" ]; then
+               rm -rf "$OUT_DIR"
+               echo "Cleaned up generated files. Exiting"
+               exit
+       fi
+}
+
+# Generate sandbox U-Boot - gleaned from /test/dm/test-dm.sh
+function compile_sandbox() {
+       unset CROSS_COMPILE
+       NUM_CPUS=$(cat /proc/cpuinfo |grep -c processor)
+       make O=sandbox sandbox_config
+       make O=sandbox -s -j${NUM_CPUS}
+
+       # Check if U-Boot exists
+       if [ ! -x "$UBOOT" ]; then
+               echo "$UBOOT does not exist or is not executable"
+               echo "Build error?"
+               echo "Please run this script as ./test/fs/`basename $0`"
+               exit
+       fi
+}
+
+# Clean out all generated files other than the file system images
+# We save time by not deleting and recreating the file system images
+function prepare_env() {
+       rm -f ${MD5_FILE}.* ${OUT}.*
+       mkdir ${OUT_DIR}
+}
+
+# 1st parameter is the name of the image file to be created
+# 2nd parameter is the filesystem - fat ext4 etc
+# -F cant be used with fat as it means something else.
+function create_image() {
+       # Create image if not already present - saves time, while debugging
+       if [ "$2" = "ext4" ]; then
+               MKFS_OPTION="-F"
+       else
+               MKFS_OPTION=""
+       fi
+       if [ ! -f "$1" ]; then
+               fallocate -l 3G "$1" &> /dev/null
+               mkfs -t "$2" $MKFS_OPTION "$1" &> /dev/null
+               if [ $? -ne 0 -a "$2" = "fat" ]; then
+                       # If we fail and we did fat, try vfat.
+                       mkfs -t vfat $MKFS_OPTION "$1" &> /dev/null
+               fi
+       fi
+}
+
+# 1st parameter is the FS type: fat/ext4
+# 2nd parameter is the name of small file
+# Returns filename which can be used for fat or ext4 for writing
+function fname_for_write() {
+       case $1 in
+               ext4)
+                       # ext4 needs absolute path name of file
+                       echo /${2}.w
+                       ;;
+
+               *)
+                       echo ${2}.w
+                       ;;
+       esac
+}
+
+# 1st parameter is image file
+# 2nd parameter is file system type - fat/ext4
+# 3rd parameter is name of small file
+# 4th parameter is name of big file
+# 5th parameter is fs/nonfs/sb - to dictate generic fs commands or
+# otherwise or sb hostfs
+# 6th parameter is the directory path for the files. Its "" for generic
+# fs and ext4/fat and full patch for sb hostfs
+# UBOOT is set in env
+function test_image() {
+       addr="0x01000008"
+       length="0x00100000"
+
+       case "$2" in
+               fat)
+               PREFIX="fat"
+               WRITE="write"
+               ;;
+
+               ext4)
+               PREFIX="ext4"
+               WRITE="write"
+               ;;
+
+               *)
+               echo "Unhandled filesystem $2. Exiting!"
+               exit
+               ;;
+       esac
+
+       case "$5" in
+               fs)
+               PREFIX=""
+               WRITE="save"
+               SUFFIX=" 0:0"
+               ;;
+
+               nonfs)
+               SUFFIX=" 0:0"
+               ;;
+
+               sb)
+               PREFIX="sb "
+               WRITE="save"
+               SUFFIX="fs -"
+               ;;
+
+               *)
+               echo "Unhandled mode $5. Exiting!"
+               exit
+               ;;
+
+       esac
+
+       if [ -z "$6" ]; then
+               FILE_WRITE=`fname_for_write $2 $3`
+               FILE_SMALL=$3
+               FILE_BIG=$4
+       else
+               FILE_WRITE=$6/`fname_for_write $2 $3`
+               FILE_SMALL=$6/$3
+               FILE_BIG=$6/$4
+       fi
+
+       # In u-boot commands, <interface> stands for host or hostfs
+       # hostfs maps to the host fs.
+       # host maps to the "sb bind" that we do
+
+       $UBOOT << EOF
+sb=$5
+setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
+run bind
+# Test Case 1 - ls
+${PREFIX}ls host${SUFFIX} $6
+#
+# We want ${PREFIX}size host 0:0 $3 for host commands and
+# sb size hostfs - $3 for hostfs commands.
+# 1MB is 0x0010 0000
+# Test Case 2 - size of small file
+${PREFIX}size host${SUFFIX} $FILE_SMALL
+printenv filesize
+setenv filesize
+
+# 2.5GB (1024*1024*2500) is 0x9C40 0000
+# Test Case 3 - size of big file
+${PREFIX}size host${SUFFIX} $FILE_BIG
+printenv filesize
+setenv filesize
+
+# Notes about load operation
+# If I use 0x01000000 I get DMA misaligned error message
+# Last two parameters are size and offset.
+
+# Test Case 4a - Read full 1MB of small file
+${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
+printenv filesize
+# Test Case 4b - Read full 1MB of small file
+md5sum $addr \$filesize
+setenv filesize
+
+# Test Case 5a - First 1MB of big file
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x0
+printenv filesize
+# Test Case 5b - First 1MB of big file
+md5sum $addr \$filesize
+setenv filesize
+
+# fails for ext as no offset support
+# Test Case 6a - Last 1MB of big file
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x9C300000
+printenv filesize
+# Test Case 6b - Last 1MB of big file
+md5sum $addr \$filesize
+setenv filesize
+
+# fails for ext as no offset support
+# Test Case 7a - One from the last 1MB chunk of 2GB
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF00000
+printenv filesize
+# Test Case 7b - One from the last 1MB chunk of 2GB
+md5sum $addr \$filesize
+setenv filesize
+
+# fails for ext as no offset support
+# Test Case 8a - One from the start 1MB chunk from 2GB
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x80000000
+printenv filesize
+# Test Case 8b - One from the start 1MB chunk from 2GB
+md5sum $addr \$filesize
+setenv filesize
+
+# fails for ext as no offset support
+# Test Case 9a - One 1MB chunk crossing the 2GB boundary
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF80000
+printenv filesize
+# Test Case 9b - One 1MB chunk crossing the 2GB boundary
+md5sum $addr \$filesize
+setenv filesize
+
+# Generic failure case
+# Test Case 10 - 2MB chunk from the last 1MB of big file
+${PREFIX}load host${SUFFIX} $addr $FILE_BIG 0x00200000 0x9C300000
+printenv filesize
+#
+
+# Read 1MB from small file
+${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
+# Write it back to test the writes
+# Test Case 11a - Check that the write succeeded
+${PREFIX}${WRITE} host${SUFFIX} $addr $FILE_WRITE \$filesize
+mw.b $addr 00 100
+${PREFIX}load host${SUFFIX} $addr $FILE_WRITE
+# Test Case 11b - Check md5 of written to is same as the one read from
+md5sum $addr \$filesize
+setenv filesize
+#
+reset
+
+EOF
+}
+
+# 1st argument is the name of the image file.
+# 2nd argument is the file where we generate the md5s of the files
+# generated with the appropriate start and length that we use to test.
+# It creates the necessary files in the image to test.
+# $GB2p5 is the path of the big file (2.5 GB)
+# $MB1 is the path of the small file (1 MB)
+# $MOUNT_DIR is the path we can use to mount the image file.
+function create_files() {
+       # Mount the image so we can populate it.
+       mkdir -p "$MOUNT_DIR"
+       sudo mount -o loop,rw "$1" "$MOUNT_DIR"
+
+       # Create big file in this image.
+       # Note that we work only on the start 1MB, couple MBs in the 2GB range
+       # and the last 1 MB of the huge 2.5GB file.
+       # So, just put random values only in those areas.
+       if [ ! -f "${GB2p5}" ]; then
+               sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 \
+                       &> /dev/null
+               sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=2 seek=2047 \
+                       &> /dev/null
+               sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 seek=2499 \
+                       &> /dev/null
+       fi
+
+       # Create a small file in this image.
+       if [ ! -f "${MB1}" ]; then
+               sudo dd if=/dev/urandom of="${MB1}" bs=1M count=1 \
+                       &> /dev/null
+       fi
+
+       # Delete the small file which possibly is written as part of a
+       # previous test.
+       sudo rm -f "${MB1}.w"
+
+       # Generate the md5sums of reads that we will test against small file
+       dd if="${MB1}" bs=1M skip=0 count=1 2> /dev/null | md5sum > "$2"
+
+       # Generate the md5sums of reads that we will test against big file
+       # One from beginning of file.
+       dd if="${GB2p5}" bs=1M skip=0 count=1 \
+               2> /dev/null | md5sum >> "$2"
+
+       # One from end of file.
+       dd if="${GB2p5}" bs=1M skip=2499 count=1 \
+               2> /dev/null | md5sum >> "$2"
+
+       # One from the last 1MB chunk of 2GB
+       dd if="${GB2p5}" bs=1M skip=2047 count=1 \
+               2> /dev/null | md5sum >> "$2"
+
+       # One from the start 1MB chunk from 2GB
+       dd if="${GB2p5}" bs=1M skip=2048 count=1 \
+               2> /dev/null | md5sum >> "$2"
+
+       # One 1MB chunk crossing the 2GB boundary
+       dd if="${GB2p5}" bs=512K skip=4095 count=2 \
+               2> /dev/null | md5sum >> "$2"
+
+       sync
+       sudo umount "$MOUNT_DIR"
+       rmdir "$MOUNT_DIR"
+}
+
+# 1st parameter is the text to print
+# if $? is 0 its a pass, else a fail
+# As a side effect it shall update env variable PASS and FAIL
+function pass_fail() {
+       if [ $? -eq 0 ]; then
+               echo pass - "$1"
+               PASS=$((PASS + 1))
+       else
+               echo FAIL - "$1"
+               FAIL=$((FAIL + 1))
+       fi
+}
+
+# 1st parameter is the string which leads to an md5 generation
+# 2nd parameter is the file we grep, for that string
+# 3rd parameter is the name of the file which has md5s in it
+# 4th parameter is the line # in the md5 file that we match it against
+# This function checks if the md5 of the file in the sandbox matches
+# that calculated while generating the file
+# 5th parameter is the string to print with the result
+check_md5() {
+       # md5sum in u-boot has output of form:
+       # md5 for 01000008 ... 01100007 ==> <md5>
+       # the 7th field is the actual md5
+       md5_src=`grep -A3 "$1" "$2" | grep "md5 for"`
+       md5_src=($md5_src)
+       md5_src=${md5_src[6]}
+
+       # The md5 list, each line is of the form:
+       # - <md5>
+       # the 2nd field is the actual md5
+       md5_dst=`sed -n $4p $3`
+       md5_dst=($md5_dst)
+       md5_dst=${md5_dst[0]}
+
+       # For a pass they should match.
+       [ "$md5_src" = "$md5_dst" ]
+       pass_fail "$5"
+}
+
+# 1st parameter is the name of the output file to check
+# 2nd parameter is the name of the file containing the md5 expected
+# 3rd parameter is the name of the small file
+# 4th parameter is the name of the big file
+# 5th paramter is the name of the written file
+# This function checks the output file for correct results.
+function check_results() {
+       echo "** Start $1"
+
+       PASS=0
+       FAIL=0
+
+       # Check if the ls is showing correct results for 2.5 gb file
+       grep -A6 "Test Case 1 " "$1" | egrep -iq "2621440000 *$4"
+       pass_fail "TC1: ls of $4"
+
+       # Check if the ls is showing correct results for 1 mb file
+       grep -A6 "Test Case 1 " "$1" | egrep -iq "1048576 *$3"
+       pass_fail "TC1: ls of $3"
+
+       # Check size command on 1MB.file
+       egrep -A3 "Test Case 2 " "$1" | grep -q "filesize=100000"
+       pass_fail "TC2: size of $3"
+
+       # Check size command on 2.5GB.file
+       egrep -A3 "Test Case 3 " "$1" | grep -q "filesize=9c400000"
+       pass_fail "TC3: size of $4"
+
+       # Check read full mb of 1MB.file
+       grep -A6 "Test Case 4a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC4: load of $3 size"
+       check_md5 "Test Case 4b " "$1" "$2" 1 "TC4: load from $3"
+
+       # Check first mb of 2.5GB.file
+       grep -A6 "Test Case 5a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC5: load of 1st MB from $4 size"
+       check_md5 "Test Case 5b " "$1" "$2" 2 "TC5: load of 1st MB from $4"
+
+       # Check last mb of 2.5GB.file
+       grep -A6 "Test Case 6a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC6: load of last MB from $4 size"
+       check_md5 "Test Case 6b " "$1" "$2" 3 "TC6: load of last MB from $4"
+
+       # Check last 1mb chunk of 2gb from 2.5GB file
+       grep -A6 "Test Case 7a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC7: load of last 1mb chunk of 2GB from $4 size"
+       check_md5 "Test Case 7b " "$1" "$2" 4 \
+               "TC7: load of last 1mb chunk of 2GB from $4"
+
+       # Check first 1mb chunk after 2gb from 2.5GB file
+       grep -A6 "Test Case 8a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC8: load 1st MB chunk after 2GB from $4 size"
+       check_md5 "Test Case 8b " "$1" "$2" 5 \
+               "TC8: load 1st MB chunk after 2GB from $4"
+
+       # Check 1mb chunk crossing the 2gb boundary from 2.5GB file
+       grep -A6 "Test Case 9a " "$1" | grep -q "filesize=100000"
+       pass_fail "TC9: load 1MB chunk crossing 2GB boundary from $4 size"
+       check_md5 "Test Case 9b " "$1" "$2" 6 \
+               "TC9: load 1MB chunk crossing 2GB boundary from $4"
+
+       # Check 2mb chunk from the last 1MB of 2.5GB file - generic failure case
+       grep -A6 "Test Case 10 " "$1" | grep -q 'Error: "filesize" not defined'
+       pass_fail "TC10: load 2MB from the last 1MB of $4 - generic fail case"
+
+       # Check 1mb chunk write
+       grep -A3 "Test Case 11a " "$1" | \
+               egrep -q '1048576 bytes written|update journal'
+       pass_fail "TC11: 1MB write to $5 - write succeeded"
+       check_md5 "Test Case 11b " "$1" "$2" 1 \
+               "TC11: 1MB write to $5 - content verified"
+       echo "** End $1"
+}
+
+# Takes in one parameter which is "fs" or "nonfs", which then dictates
+# if a fs test (size/load/save) or a nonfs test (fatread/extread) needs to
+# be performed.
+function test_fs_nonfs() {
+       echo "Creating files in $fs image if not already present."
+       create_files $IMAGE $MD5_FILE_FS
+
+       OUT_FILE="${OUT}.fs.${fs}.out"
+       test_image $IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
+               > ${OUT_FILE}
+       check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
+               $WRITE_FILE
+       TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
+       TOTAL_PASS=$((TOTAL_PASS + PASS))
+       echo "Summary: PASS: $PASS FAIL: $FAIL"
+       echo "--------------------------------------------"
+}
+
+# ********************
+# * End of functions *
+# ********************
+
+check_clean "$1"
+check_prereq
+compile_sandbox
+prepare_env
+
+# Track TOTAL_FAIL and TOTAL_PASS
+TOTAL_FAIL=0
+TOTAL_PASS=0
+
+# In each loop, for a given file system image, we test both the
+# fs command, like load/size/write, the file system specific command
+# like: ext4load/ext4size/ext4write and the sb load/ls/save commands.
+for fs in ext4 fat; do
+
+       echo "Creating $fs image if not already present."
+       IMAGE=${IMG}.${fs}.img
+       MD5_FILE_FS="${MD5_FILE}.${fs}"
+       create_image $IMAGE $fs
+
+       # sb commands test
+       echo "Creating files in $fs image if not already present."
+       create_files $IMAGE $MD5_FILE_FS
+
+       # Lets mount the image and test sb hostfs commands
+       mkdir -p "$MOUNT_DIR"
+       if [ "$fs" = "fat" ]; then
+               uid="uid=`id -u`"
+       else
+               uid=""
+       fi
+       sudo mount -o loop,rw,$uid "$IMAGE" "$MOUNT_DIR"
+       sudo chmod 777 "$MOUNT_DIR"
+
+       OUT_FILE="${OUT}.sb.${fs}.out"
+       test_image $IMAGE $fs $SMALL_FILE $BIG_FILE sb `pwd`/$MOUNT_DIR \
+               > ${OUT_FILE}
+       sudo umount "$MOUNT_DIR"
+       rmdir "$MOUNT_DIR"
+
+       check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
+               $WRITE_FILE
+       TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
+       TOTAL_PASS=$((TOTAL_PASS + PASS))
+       echo "Summary: PASS: $PASS FAIL: $FAIL"
+       echo "--------------------------------------------"
+
+       test_fs_nonfs nonfs
+       test_fs_nonfs fs
+done
+
+echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
+echo "--------------------------------------------"
+if [ $TOTAL_FAIL -eq 0 ]; then
+       echo "PASSED"
+       exit 0
+else
+       echo "FAILED"
+       exit 1
+fi