Eric Lee / smarc-uboot | Embedian Git Server

Commit 6c016485a685b5cdac28edb25147311a3e88d51f

Authored by Suriyan Ramasami 2014-11-18 06:39:39 +0800

Committed by Tom Rini 2014-11-23 19:49:05 +0800

Exists in v2017.01-smarct4x and in 37 other branches

sandbox: script for testing sandbox/ext4/fat/fs commands

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>

Showing 1 changed file with 561 additions and 0 deletions Inline Diff

test/fs/fs-test.sh

test/fs/fs-test.sh

Diff comments View file @ 6c01648

File was created	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: 17 FAIL: 2
	13	# fs-test.ext4.out: Summary: PASS: 11 FAIL: 8
	14	# fs-test.fs.ext4.out: Summary: PASS: 11 FAIL: 8
	15	# FAT tests:
	16	# fs-test.sb.fat.out: Summary: PASS: 17 FAIL: 2
	17	# fs-test.fat.out: Summary: PASS: 19 FAIL: 0
	18	# fs-test.fs.fat.out: Summary: PASS: 19 FAIL: 0
	19	# Total Summary: TOTAL PASS: 94 TOTAL FAIL: 20
	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 ${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	mkfs -t "$2" $MKFS_OPTION "$1" &> /dev/null
	119	if [ $? -ne 0 -a "$2" = "fat" ]; then
	120	# If we fail and we did fat, try vfat.
	121	mkfs -t vfat $MKFS_OPTION "$1" &> /dev/null
	122	fi
	123	fi
	124	}
	125
	126	# 1st parameter is the FS type: fat/ext4
	127	# 2nd parameter is the name of small file
	128	# Returns filename which can be used for fat or ext4 for writing
	129	function fname_for_write() {
	130	case $1 in
	131	ext4)
	132	# ext4 needs absolute path name of file
	133	echo /${2}.w
	134	;;
	135
	136	*)
	137	echo ${2}.w
	138	;;
	139	esac
	140	}
	141
	142	# 1st parameter is image file
	143	# 2nd parameter is file system type - fat/ext4
	144	# 3rd parameter is name of small file
	145	# 4th parameter is name of big file
	146	# 5th parameter is fs/nonfs/sb - to dictate generic fs commands or
	147	# otherwise or sb hostfs
	148	# 6th parameter is the directory path for the files. Its "" for generic
	149	# fs and ext4/fat and full patch for sb hostfs
	150	# UBOOT is set in env
	151	function test_image() {
	152	addr="0x01000008"
	153	length="0x00100000"
	154
	155	case "$2" in
	156	fat)
	157	PREFIX="fat"
	158	WRITE="write"
	159	;;
	160
	161	ext4)
	162	PREFIX="ext4"
	163	WRITE="write"
	164	;;
	165
	166	*)
	167	echo "Unhandled filesystem $2. Exiting!"
	168	exit
	169	;;
	170	esac
	171
	172	case "$5" in
	173	fs)
	174	PREFIX=""
	175	WRITE="save"
	176	SUFFIX=" 0:0"
	177	;;
	178
	179	nonfs)
	180	SUFFIX=" 0:0"
	181	;;
	182
	183	sb)
	184	PREFIX="sb "
	185	WRITE="save"
	186	SUFFIX="fs -"
	187	;;
	188
	189	*)
	190	echo "Unhandled mode $5. Exiting!"
	191	exit
	192	;;
	193
	194	esac
	195
	196	if [ -z "$6" ]; then
	197	FILE_WRITE=`fname_for_write $2 $3`
	198	FILE_SMALL=$3
	199	FILE_BIG=$4
	200	else
	201	FILE_WRITE=$6/`fname_for_write $2 $3`
	202	FILE_SMALL=$6/$3
	203	FILE_BIG=$6/$4
	204	fi
	205
	206	# In u-boot commands, <interface> stands for host or hostfs
	207	# hostfs maps to the host fs.
	208	# host maps to the "sb bind" that we do
	209
	210	$UBOOT << EOF
	211	sb=$5
	212	setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
	213	run bind
	214	# Test Case 1 - ls
	215	${PREFIX}ls host${SUFFIX} $6
	216	#
	217	# We want ${PREFIX}size host 0:0 $3 for host commands and
	218	# sb size hostfs - $3 for hostfs commands.
	219	# 1MB is 0x0010 0000
	220	# Test Case 2 - size of small file
	221	${PREFIX}size host${SUFFIX} $FILE_SMALL
	222	printenv filesize
	223	setenv filesize
	224
	225	# 2.5GB (102410242500) is 0x9C40 0000
	226	# Test Case 3 - size of big file
	227	${PREFIX}size host${SUFFIX} $FILE_BIG
	228	printenv filesize
	229	setenv filesize
	230
	231	# Notes about load operation
	232	# If I use 0x01000000 I get DMA misaligned error message
	233	# Last two parameters are size and offset.
	234
	235	# Test Case 4a - Read full 1MB of small file
	236	${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
	237	printenv filesize
	238	# Test Case 4b - Read full 1MB of small file
	239	md5sum $addr \$filesize
	240	setenv filesize
	241
	242	# Test Case 5a - First 1MB of big file
	243	${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x0
	244	printenv filesize
	245	# Test Case 5b - First 1MB of big file
	246	md5sum $addr \$filesize
	247	setenv filesize
	248
	249	# fails for ext as no offset support
	250	# Test Case 6a - Last 1MB of big file
	251	${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x9C300000
	252	printenv filesize
	253	# Test Case 6b - Last 1MB of big file
	254	md5sum $addr \$filesize
	255	setenv filesize
	256
	257	# fails for ext as no offset support
	258	# Test Case 7a - One from the last 1MB chunk of 2GB
	259	${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF00000
	260	printenv filesize
	261	# Test Case 7b - One from the last 1MB chunk of 2GB
	262	md5sum $addr \$filesize
	263	setenv filesize
	264
	265	# fails for ext as no offset support
	266	# Test Case 8a - One from the start 1MB chunk from 2GB
	267	${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x80000000
	268	printenv filesize
	269	# Test Case 8b - One from the start 1MB chunk from 2GB
	270	md5sum $addr \$filesize
	271	setenv filesize
	272
	273	# fails for ext as no offset support
	274	# Test Case 9a - One 1MB chunk crossing the 2GB boundary
	275	${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF80000
	276	printenv filesize
	277	# Test Case 9b - One 1MB chunk crossing the 2GB boundary
	278	md5sum $addr \$filesize
	279	setenv filesize
	280
	281	# Generic failure case
	282	# Test Case 10 - 2MB chunk from the last 1MB of big file
	283	${PREFIX}load host${SUFFIX} $addr $FILE_BIG 0x00200000 0x9C300000
	284	printenv filesize
	285	#
	286
	287	# Read 1MB from small file
	288	${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
	289	# Write it back to test the writes
	290	# Test Case 11a - Check that the write succeeded
	291	${PREFIX}${WRITE} host${SUFFIX} $addr $FILE_WRITE \$filesize
	292	mw.b $addr 00 100
	293	${PREFIX}load host${SUFFIX} $addr $FILE_WRITE
	294	# Test Case 11b - Check md5 of written to is same as the one read from
	295	md5sum $addr \$filesize
	296	setenv filesize
	297	#
	298	reset
	299
	300	EOF
	301	}
	302
	303	# 1st argument is the name of the image file.
	304	# 2nd argument is the file where we generate the md5s of the files
	305	# generated with the appropriate start and length that we use to test.
	306	# It creates the necessary files in the image to test.
	307	# $GB2p5 is the path of the big file (2.5 GB)
	308	# $MB1 is the path of the small file (1 MB)
	309	# $MOUNT_DIR is the path we can use to mount the image file.
	310	function create_files() {
	311	# Mount the image so we can populate it.
	312	mkdir -p "$MOUNT_DIR"
	313	sudo mount -o loop,rw "$1" "$MOUNT_DIR"
	314
	315	# Create big file in this image.
	316	# Note that we work only on the start 1MB, couple MBs in the 2GB range
	317	# and the last 1 MB of the huge 2.5GB file.
	318	# So, just put random values only in those areas.
	319	if [ ! -f "${GB2p5}" ]; then
	320	sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 \
	321	&> /dev/null
	322	sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=2 seek=2047 \
	323	&> /dev/null
	324	sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 seek=2499 \
	325	&> /dev/null
	326	fi
	327
	328	# Create a small file in this image.
	329	if [ ! -f "${MB1}" ]; then
	330	sudo dd if=/dev/urandom of="${MB1}" bs=1M count=1 \
	331	&> /dev/null
	332	fi
	333
	334	# Delete the small file which possibly is written as part of a
	335	# previous test.
	336	sudo rm -f "${MB1}.w"
	337
	338	# Generate the md5sums of reads that we will test against small file
	339	dd if="${MB1}" bs=1M skip=0 count=1 2> /dev/null \| md5sum > "$2"
	340
	341	# Generate the md5sums of reads that we will test against big file
	342	# One from beginning of file.
	343	dd if="${GB2p5}" bs=1M skip=0 count=1 \
	344	2> /dev/null \| md5sum >> "$2"
	345
	346	# One from end of file.
	347	dd if="${GB2p5}" bs=1M skip=2499 count=1 \
	348	2> /dev/null \| md5sum >> "$2"
	349
	350	# One from the last 1MB chunk of 2GB
	351	dd if="${GB2p5}" bs=1M skip=2047 count=1 \
	352	2> /dev/null \| md5sum >> "$2"
	353
	354	# One from the start 1MB chunk from 2GB
	355	dd if="${GB2p5}" bs=1M skip=2048 count=1 \
	356	2> /dev/null \| md5sum >> "$2"
	357
	358	# One 1MB chunk crossing the 2GB boundary
	359	dd if="${GB2p5}" bs=512K skip=4095 count=2 \
	360	2> /dev/null \| md5sum >> "$2"
	361
	362	sync
	363	sudo umount "$MOUNT_DIR"
	364	rmdir "$MOUNT_DIR"
	365	}
	366
	367	# 1st parameter is the text to print
	368	# if $? is 0 its a pass, else a fail
	369	# As a side effect it shall update env variable PASS and FAIL
	370	function pass_fail() {
	371	if [ $? -eq 0 ]; then
	372	echo pass - "$1"
	373	PASS=$((PASS + 1))
	374	else
	375	echo FAIL - "$1"
	376	FAIL=$((FAIL + 1))
	377	fi
	378	}
	379
	380	# 1st parameter is the string which leads to an md5 generation
	381	# 2nd parameter is the file we grep, for that string
	382	# 3rd parameter is the name of the file which has md5s in it
	383	# 4th parameter is the line # in the md5 file that we match it against
	384	# This function checks if the md5 of the file in the sandbox matches
	385	# that calculated while generating the file
	386	# 5th parameter is the string to print with the result
	387	check_md5() {
	388	# md5sum in u-boot has output of form:
	389	# md5 for 01000008 ... 01100007 ==> <md5>
	390	# the 7th field is the actual md5
	391	md5_src=`grep -A3 "$1" "$2" \| grep "md5 for"`
	392	md5_src=($md5_src)
	393	md5_src=${md5_src[6]}
	394
	395	# The md5 list, each line is of the form:
	396	# - <md5>
	397	# the 2nd field is the actual md5
	398	md5_dst=`sed -n $4p $3`
	399	md5_dst=($md5_dst)
	400	md5_dst=${md5_dst[0]}
	401
	402	# For a pass they should match.
	403	[ "$md5_src" = "$md5_dst" ]
	404	pass_fail "$5"
	405	}
	406
	407	# 1st parameter is the name of the output file to check
	408	# 2nd parameter is the name of the file containing the md5 expected
	409	# 3rd parameter is the name of the small file
	410	# 4th parameter is the name of the big file
	411	# 5th paramter is the name of the written file
	412	# This function checks the output file for correct results.
	413	function check_results() {
	414	echo "** Start $1"
	415
	416	PASS=0
	417	FAIL=0
	418
	419	# Check if the ls is showing correct results for 2.5 gb file
	420	grep -A6 "Test Case 1 " "$1" \| egrep -iq "2621440000 *$4"
	421	pass_fail "TC1: ls of $4"
	422
	423	# Check if the ls is showing correct results for 1 mb file
	424	grep -A6 "Test Case 1 " "$1" \| egrep -iq "1048576 *$3"
	425	pass_fail "TC1: ls of $3"
	426
	427	# Check size command on 1MB.file
	428	egrep -A3 "Test Case 2 " "$1" \| grep -q "filesize=100000"
	429	pass_fail "TC2: size of $3"
	430
	431	# Check size command on 2.5GB.file
	432	egrep -A3 "Test Case 3 " "$1" \| grep -q "filesize=9c400000"
	433	pass_fail "TC3: size of $4"
	434
	435	# Check read full mb of 1MB.file
	436	grep -A6 "Test Case 4a " "$1" \| grep -q "filesize=100000"
	437	pass_fail "TC4: load of $3 size"
	438	check_md5 "Test Case 4b " "$1" "$2" 1 "TC4: load from $3"
	439
	440	# Check first mb of 2.5GB.file
	441	grep -A6 "Test Case 5a " "$1" \| grep -q "filesize=100000"
	442	pass_fail "TC5: load of 1st MB from $4 size"
	443	check_md5 "Test Case 5b " "$1" "$2" 2 "TC5: load of 1st MB from $4"
	444
	445	# Check last mb of 2.5GB.file
	446	grep -A6 "Test Case 6a " "$1" \| grep -q "filesize=100000"
	447	pass_fail "TC6: load of last MB from $4 size"
	448	check_md5 "Test Case 6b " "$1" "$2" 3 "TC6: load of last MB from $4"
	449
	450	# Check last 1mb chunk of 2gb from 2.5GB file
	451	grep -A6 "Test Case 7a " "$1" \| grep -q "filesize=100000"
	452	pass_fail "TC7: load of last 1mb chunk of 2GB from $4 size"
	453	check_md5 "Test Case 7b " "$1" "$2" 4 \
	454	"TC7: load of last 1mb chunk of 2GB from $4"
	455
	456	# Check first 1mb chunk after 2gb from 2.5GB file
	457	grep -A6 "Test Case 8a " "$1" \| grep -q "filesize=100000"
	458	pass_fail "TC8: load 1st MB chunk after 2GB from $4 size"
	459	check_md5 "Test Case 8b " "$1" "$2" 5 \
	460	"TC8: load 1st MB chunk after 2GB from $4"
	461
	462	# Check 1mb chunk crossing the 2gb boundary from 2.5GB file
	463	grep -A6 "Test Case 9a " "$1" \| grep -q "filesize=100000"
	464	pass_fail "TC9: load 1MB chunk crossing 2GB boundary from $4 size"
	465	check_md5 "Test Case 9b " "$1" "$2" 6 \
	466	"TC9: load 1MB chunk crossing 2GB boundary from $4"
	467
	468	# Check 2mb chunk from the last 1MB of 2.5GB file - generic failure case
	469	grep -A6 "Test Case 10 " "$1" \| grep -q 'Error: "filesize" not defined'
	470	pass_fail "TC10: load 2MB from the last 1MB of $4 - generic fail case"
	471
	472	# Check 1mb chunk write
	473	grep -A3 "Test Case 11a " "$1" \| \
	474	egrep -q '1048576 bytes written\|update journal'
	475	pass_fail "TC11: 1MB write to $5 - write succeeded"
	476	check_md5 "Test Case 11b " "$1" "$2" 1 \
	477	"TC11: 1MB write to $5 - content verified"
	478	echo "** End $1"
	479	}
	480
	481	# Takes in one parameter which is "fs" or "nonfs", which then dictates
	482	# if a fs test (size/load/save) or a nonfs test (fatread/extread) needs to
	483	# be performed.
	484	function test_fs_nonfs() {
	485	echo "Creating files in $fs image if not already present."
	486	create_files $IMAGE $MD5_FILE_FS
	487
	488	OUT_FILE="${OUT}.fs.${fs}.out"
	489	test_image $IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
	490	> ${OUT_FILE}
	491	check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
	492	$WRITE_FILE
	493	TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
	494	TOTAL_PASS=$((TOTAL_PASS + PASS))
	495	echo "Summary: PASS: $PASS FAIL: $FAIL"
	496	echo "--------------------------------------------"
	497	}
	498
	499	# ********************
	500	# * End of functions *
	501	# ********************
	502
	503	check_clean "$1"
	504	check_prereq
	505	compile_sandbox
	506	prepare_env
	507
	508	# Track TOTAL_FAIL and TOTAL_PASS
	509	TOTAL_FAIL=0
	510	TOTAL_PASS=0
	511
	512	# In each loop, for a given file system image, we test both the
	513	# fs command, like load/size/write, the file system specific command
	514	# like: ext4load/ext4size/ext4write and the sb load/ls/save commands.
	515	for fs in ext4 fat; do
	516
	517	echo "Creating $fs image if not already present."
	518	IMAGE=${IMG}.${fs}.img
	519	MD5_FILE_FS="${MD5_FILE}.${fs}"
	520	create_image $IMAGE $fs
	521
	522	# sb commands test
	523	echo "Creating files in $fs image if not already present."
	524	create_files $IMAGE $MD5_FILE_FS
	525
	526	# Lets mount the image and test sb hostfs commands
	527	mkdir -p "$MOUNT_DIR"
	528	if [ "$fs" = "fat" ]; then
	529	uid="uid=`id -u`"
	530	else
	531	uid=""
	532	fi
	533	sudo mount -o loop,rw,$uid "$IMAGE" "$MOUNT_DIR"
	534	sudo chmod 777 "$MOUNT_DIR"
	535
	536	OUT_FILE="${OUT}.sb.${fs}.out"
	537	test_image $IMAGE $fs $SMALL_FILE $BIG_FILE sb `pwd`/$MOUNT_DIR \
	538	> ${OUT_FILE}
	539	sudo umount "$MOUNT_DIR"
	540	rmdir "$MOUNT_DIR"
	541
	542	check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
	543	$WRITE_FILE
	544	TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
	545	TOTAL_PASS=$((TOTAL_PASS + PASS))
	546	echo "Summary: PASS: $PASS FAIL: $FAIL"
	547	echo "--------------------------------------------"
	548
	549	test_fs_nonfs nonfs
	550	test_fs_nonfs fs
	551	done
	552
	553	echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
	554	echo "--------------------------------------------"
	555	if [ $TOTAL_FAIL -eq 0 ]; then
	556	echo "PASSED"
	557	exit 0
	558	else
	559	echo "FAILED"
	560	exit 1
	561	fi
	562