3 # (C) Copyright 2014 Suriyan Ramasami
5 # SPDX-License-Identifier: GPL-2.0+
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:
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
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
21 # pre-requisite binaries list.
22 PREREQ_BINS="md5sum mkfs mount umount dd fallocate mkdir"
24 # All generated output files from this test will be in $OUT_DIR
25 # Hence everything is sandboxed.
26 OUT_DIR="sandbox/test/fs"
28 # Location of generated sandbox u-boot
29 UBOOT="./sandbox/u-boot"
31 # Our mount directory will be in the sandbox
32 MOUNT_DIR="${OUT_DIR}/mnt"
34 # The file system image we create will have the $IMG prefix.
37 # $SMALL_FILE is the name of the 1MB file in the file system image
40 # $BIG_FILE is the name of the 2.5GB file in the file system image
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"
47 # $OUT shall be the prefix of the test output. Their suffix will be .out
48 OUT="${OUT_DIR}/fs-test"
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}"
54 # ************************
55 # * Functions start here *
56 # ************************
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!"
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!"
74 # If 1st param is "clean", then clean out the generated files and exit
75 function check_clean() {
76 if [ "$1" = "clean" ]; then
78 echo "Cleaned up generated files. Exiting"
83 # Generate sandbox U-Boot - gleaned from /test/dm/test-dm.sh
84 function compile_sandbox() {
86 NUM_CPUS=$(cat /proc/cpuinfo |grep -c processor)
87 make O=sandbox sandbox_config
88 make O=sandbox -s -j${NUM_CPUS}
90 # Check if U-Boot exists
91 if [ ! -x "$UBOOT" ]; then
92 echo "$UBOOT does not exist or is not executable"
94 echo "Please run this script as ./test/fs/`basename $0`"
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}.*
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
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
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() {
132 # ext4 needs absolute path name of file
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() {
167 echo "Unhandled filesystem $2. Exiting!"
190 echo "Unhandled mode $5. Exiting!"
197 FILE_WRITE=`fname_for_write $2 $3`
201 FILE_WRITE=$6/`fname_for_write $2 $3`
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
212 setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
215 ${PREFIX}ls host${SUFFIX} $6
217 # We want ${PREFIX}size host 0:0 $3 for host commands and
218 # sb size hostfs - $3 for hostfs commands.
220 # Test Case 2 - size of small file
221 ${PREFIX}size host${SUFFIX} $FILE_SMALL
225 # 2.5GB (1024*1024*2500) is 0x9C40 0000
226 # Test Case 3 - size of big file
227 ${PREFIX}size host${SUFFIX} $FILE_BIG
231 # Notes about load operation
232 # If I use 0x01000000 I get DMA misaligned error message
233 # Last two parameters are size and offset.
235 # Test Case 4a - Read full 1MB of small file
236 ${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
238 # Test Case 4b - Read full 1MB of small file
239 md5sum $addr \$filesize
242 # Test Case 5a - First 1MB of big file
243 ${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x0
245 # Test Case 5b - First 1MB of big file
246 md5sum $addr \$filesize
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
253 # Test Case 6b - Last 1MB of big file
254 md5sum $addr \$filesize
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
261 # Test Case 7b - One from the last 1MB chunk of 2GB
262 md5sum $addr \$filesize
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
269 # Test Case 8b - One from the start 1MB chunk from 2GB
270 md5sum $addr \$filesize
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
277 # Test Case 9b - One 1MB chunk crossing the 2GB boundary
278 md5sum $addr \$filesize
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
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
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
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"
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 \
322 sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=2 seek=2047 \
324 sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 seek=2499 \
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 \
334 # Delete the small file which possibly is written as part of a
336 sudo rm -f "${MB1}.w"
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"
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"
346 # One from end of file.
347 dd if="${GB2p5}" bs=1M skip=2499 count=1 \
348 2> /dev/null | md5sum >> "$2"
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"
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"
358 # One 1MB chunk crossing the 2GB boundary
359 dd if="${GB2p5}" bs=512K skip=4095 count=2 \
360 2> /dev/null | md5sum >> "$2"
363 sudo umount "$MOUNT_DIR"
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
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
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"`
393 md5_src=${md5_src[6]}
395 # The md5 list, each line is of the form:
397 # the 2nd field is the actual md5
398 md5_dst=`sed -n $4p $3`
400 md5_dst=${md5_dst[0]}
402 # For a pass they should match.
403 [ "$md5_src" = "$md5_dst" ]
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() {
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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"
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
484 function test_fs_nonfs() {
485 echo "Creating files in $fs image if not already present."
486 create_files $IMAGE $MD5_FILE_FS
488 OUT_FILE="${OUT}.fs.${fs}.out"
489 test_image $IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
491 check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
493 TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
494 TOTAL_PASS=$((TOTAL_PASS + PASS))
495 echo "Summary: PASS: $PASS FAIL: $FAIL"
496 echo "--------------------------------------------"
499 # ********************
500 # * End of functions *
501 # ********************
508 # Track TOTAL_FAIL and TOTAL_PASS
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
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
523 echo "Creating files in $fs image if not already present."
524 create_files $IMAGE $MD5_FILE_FS
526 # Lets mount the image and test sb hostfs commands
527 mkdir -p "$MOUNT_DIR"
528 if [ "$fs" = "fat" ]; then
533 sudo mount -o loop,rw,$uid "$IMAGE" "$MOUNT_DIR"
534 sudo chmod 777 "$MOUNT_DIR"
536 OUT_FILE="${OUT}.sb.${fs}.out"
537 test_image $IMAGE $fs $SMALL_FILE $BIG_FILE sb `pwd`/$MOUNT_DIR \
539 sudo umount "$MOUNT_DIR"
542 check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
544 TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
545 TOTAL_PASS=$((TOTAL_PASS + PASS))
546 echo "Summary: PASS: $PASS FAIL: $FAIL"
547 echo "--------------------------------------------"
553 echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
554 echo "--------------------------------------------"
555 if [ $TOTAL_FAIL -eq 0 ]; then