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: 10 FAIL: 9
14 # fs-test.fs.ext4.out: Summary: PASS: 10 FAIL: 9
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: 92 TOTAL FAIL: 22
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 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
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
131 if [ $?
-ne 0 ]; then
132 echo Could not create filesystem
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
() {
159 # ext4 needs absolute path
166 echo "Unhandled filesystem $2. Exiting!"
189 echo "Unhandled mode $5. Exiting!"
195 # sb always uses full path to mointpoint, irrespective of filesystem
196 if [ "$5" = "sb" ]; then
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
210 setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
213 ${PREFIX}ls host${SUFFIX} $6
215 # We want ${PREFIX}size host 0:0 $3 for host commands and
216 # sb size hostfs - $3 for hostfs commands.
218 # Test Case 2 - size of small file
219 ${PREFIX}size host${SUFFIX} ${FPATH}$FILE_SMALL
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
229 # Notes about load operation
230 # If I use 0x01000000 I get DMA misaligned error message
231 # Last two parameters are size and offset.
233 # Test Case 4a - Read full 1MB of small file
234 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_SMALL
236 # Test Case 4b - Read full 1MB of small file
237 md5sum $addr \$filesize
240 # Test Case 5a - First 1MB of big file
241 ${PREFIX}load host${SUFFIX} $addr ${FPATH}$FILE_BIG $length 0x0
243 # Test Case 5b - First 1MB of big file
244 md5sum $addr \$filesize
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
251 # Test Case 6b - Last 1MB of big file
252 md5sum $addr \$filesize
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
259 # Test Case 7b - One from the last 1MB chunk of 2GB
260 md5sum $addr \$filesize
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
267 # Test Case 8b - One from the start 1MB chunk from 2GB
268 md5sum $addr \$filesize
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
275 # Test Case 9b - One 1MB chunk crossing the 2GB boundary
276 md5sum $addr \$filesize
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
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
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
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
307 # 1st argument is the name of the image file.
308 # 2nd argument is the file where we generate the md5s of the files
309 # generated with the appropriate start and length that we use to test.
310 # It creates the necessary files in the image to test.
311 # $GB2p5 is the path of the big file (2.5 GB)
312 # $MB1 is the path of the small file (1 MB)
313 # $MOUNT_DIR is the path we can use to mount the image file.
314 function create_files
() {
315 # Mount the image so we can populate it.
316 mkdir
-p "$MOUNT_DIR"
317 sudo mount
-o loop
,rw
"$1" "$MOUNT_DIR"
319 # Create big file in this image.
320 # Note that we work only on the start 1MB, couple MBs in the 2GB range
321 # and the last 1 MB of the huge 2.5GB file.
322 # So, just put random values only in those areas.
323 if [ ! -f "${GB2p5}" ]; then
324 sudo
dd if=/dev
/urandom of
="${GB2p5}" bs
=1M count
=1 \
326 sudo
dd if=/dev
/urandom of
="${GB2p5}" bs
=1M count
=2 seek
=2047 \
328 sudo
dd if=/dev
/urandom of
="${GB2p5}" bs
=1M count
=1 seek
=2499 \
332 # Create a small file in this image.
333 if [ ! -f "${MB1}" ]; then
334 sudo
dd if=/dev
/urandom of
="${MB1}" bs
=1M count
=1 \
338 # Delete the small file which possibly is written as part of a
340 sudo
rm -f "${MB1}.w"
342 # Generate the md5sums of reads that we will test against small file
343 dd if="${MB1}" bs
=1M skip
=0 count
=1 2> /dev
/null |
md5sum > "$2"
345 # Generate the md5sums of reads that we will test against big file
346 # One from beginning of file.
347 dd if="${GB2p5}" bs
=1M skip
=0 count
=1 \
348 2> /dev
/null |
md5sum >> "$2"
350 # One from end of file.
351 dd if="${GB2p5}" bs
=1M skip
=2499 count
=1 \
352 2> /dev
/null |
md5sum >> "$2"
354 # One from the last 1MB chunk of 2GB
355 dd if="${GB2p5}" bs
=1M skip
=2047 count
=1 \
356 2> /dev
/null |
md5sum >> "$2"
358 # One from the start 1MB chunk from 2GB
359 dd if="${GB2p5}" bs
=1M skip
=2048 count
=1 \
360 2> /dev
/null |
md5sum >> "$2"
362 # One 1MB chunk crossing the 2GB boundary
363 dd if="${GB2p5}" bs
=512K skip
=4095 count
=2 \
364 2> /dev
/null |
md5sum >> "$2"
367 sudo umount
"$MOUNT_DIR"
371 # 1st parameter is the text to print
372 # if $? is 0 its a pass, else a fail
373 # As a side effect it shall update env variable PASS and FAIL
374 function pass_fail
() {
375 if [ $?
-eq 0 ]; then
384 # 1st parameter is the string which leads to an md5 generation
385 # 2nd parameter is the file we grep, for that string
386 # 3rd parameter is the name of the file which has md5s in it
387 # 4th parameter is the line # in the md5 file that we match it against
388 # This function checks if the md5 of the file in the sandbox matches
389 # that calculated while generating the file
390 # 5th parameter is the string to print with the result
392 # md5sum in u-boot has output of form:
393 # md5 for 01000008 ... 01100007 ==> <md5>
394 # the 7th field is the actual md5
395 md5_src
=`grep -A2 "$1" "$2" | grep "md5 for" | tr -d '\r'`
397 md5_src
=${md5_src[6]}
399 # The md5 list, each line is of the form:
401 # the 2nd field is the actual md5
402 md5_dst
=`sed -n $4p $3`
404 md5_dst
=${md5_dst[0]}
406 # For a pass they should match.
407 [ "$md5_src" = "$md5_dst" ]
411 # 1st parameter is the name of the output file to check
412 # 2nd parameter is the name of the file containing the md5 expected
413 # 3rd parameter is the name of the small file
414 # 4th parameter is the name of the big file
415 # 5th paramter is the name of the written file
416 # This function checks the output file for correct results.
417 function check_results
() {
423 # Check if the ls is showing correct results for 2.5 gb file
424 grep -A6 "Test Case 1 " "$1" |
egrep -iq "2621440000 *$4"
425 pass_fail
"TC1: ls of $4"
427 # Check if the ls is showing correct results for 1 mb file
428 grep -A6 "Test Case 1 " "$1" |
egrep -iq "1048576 *$3"
429 pass_fail
"TC1: ls of $3"
431 # Check size command on 1MB.file
432 egrep -A3 "Test Case 2 " "$1" |
grep -q "filesize=100000"
433 pass_fail
"TC2: size of $3"
435 # Check size command on 2.5GB.file
436 egrep -A3 "Test Case 3 " "$1" |
grep -q "filesize=9c400000"
437 pass_fail
"TC3: size of $4"
439 # Check read full mb of 1MB.file
440 grep -A4 "Test Case 4a " "$1" |
grep -q "filesize=100000"
441 pass_fail
"TC4: load of $3 size"
442 check_md5
"Test Case 4b " "$1" "$2" 1 "TC4: load from $3"
444 # Check first mb of 2.5GB.file
445 grep -A4 "Test Case 5a " "$1" |
grep -q "filesize=100000"
446 pass_fail
"TC5: load of 1st MB from $4 size"
447 check_md5
"Test Case 5b " "$1" "$2" 2 "TC5: load of 1st MB from $4"
449 # Check last mb of 2.5GB.file
450 grep -A4 "Test Case 6a " "$1" |
grep -q "filesize=100000"
451 pass_fail
"TC6: load of last MB from $4 size"
452 check_md5
"Test Case 6b " "$1" "$2" 3 "TC6: load of last MB from $4"
454 # Check last 1mb chunk of 2gb from 2.5GB file
455 grep -A4 "Test Case 7a " "$1" |
grep -q "filesize=100000"
456 pass_fail
"TC7: load of last 1mb chunk of 2GB from $4 size"
457 check_md5
"Test Case 7b " "$1" "$2" 4 \
458 "TC7: load of last 1mb chunk of 2GB from $4"
460 # Check first 1mb chunk after 2gb from 2.5GB file
461 grep -A4 "Test Case 8a " "$1" |
grep -q "filesize=100000"
462 pass_fail
"TC8: load 1st MB chunk after 2GB from $4 size"
463 check_md5
"Test Case 8b " "$1" "$2" 5 \
464 "TC8: load 1st MB chunk after 2GB from $4"
466 # Check 1mb chunk crossing the 2gb boundary from 2.5GB file
467 grep -A4 "Test Case 9a " "$1" |
grep -q "filesize=100000"
468 pass_fail
"TC9: load 1MB chunk crossing 2GB boundary from $4 size"
469 check_md5
"Test Case 9b " "$1" "$2" 6 \
470 "TC9: load 1MB chunk crossing 2GB boundary from $4"
472 # Check 2mb chunk from the last 1MB of 2.5GB file loads 1MB
473 grep -A5 "Test Case 10 " "$1" |
grep -q "filesize=100000"
474 pass_fail
"TC10: load 2MB from the last 1MB of $4 loads 1MB"
476 # Check 1mb chunk write
477 grep -A2 "Test Case 11a " "$1" |
grep -q '1048576 bytes written'
478 pass_fail
"TC11: 1MB write to $3.w - write succeeded"
479 check_md5
"Test Case 11b " "$1" "$2" 1 \
480 "TC11: 1MB write to $3.w - content verified"
482 # Check lookup of 'dot' directory
483 grep -A4 "Test Case 12 " "$1" |
grep -q 'Unable to write file'
484 pass_fail
"TC12: 1MB write to . - write denied"
488 # Takes in one parameter which is "fs" or "nonfs", which then dictates
489 # if a fs test (size/load/save) or a nonfs test (fatread/extread) needs to
491 function test_fs_nonfs
() {
492 echo "Creating files in $fs image if not already present."
493 create_files
$IMAGE $MD5_FILE_FS
495 OUT_FILE
="${OUT}.$1.${fs}.out"
496 test_image
$IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
498 # strip out noise from fs code
499 grep -v -e "File System is consistent\|update journal finished" \
500 -e "reading .*\.file\|writing .*\.file.w" \
501 < ${OUT_FILE} > ${OUT_FILE}_clean
502 check_results
${OUT_FILE}_clean
$MD5_FILE_FS $SMALL_FILE \
504 TOTAL_FAIL
=$
((TOTAL_FAIL
+ FAIL
))
505 TOTAL_PASS
=$
((TOTAL_PASS
+ PASS
))
506 echo "Summary: PASS: $PASS FAIL: $FAIL"
507 echo "--------------------------------------------"
510 # ********************
511 # * End of functions *
512 # ********************
519 # Track TOTAL_FAIL and TOTAL_PASS
523 # In each loop, for a given file system image, we test both the
524 # fs command, like load/size/write, the file system specific command
525 # like: ext4load/ext4size/ext4write and the sb load/ls/save commands.
526 for fs
in ext4 fat
; do
528 echo "Creating $fs image if not already present."
529 IMAGE
=${IMG}.
${fs}.img
530 MD5_FILE_FS
="${MD5_FILE}.${fs}"
531 create_image
$IMAGE $fs
534 echo "Creating files in $fs image if not already present."
535 create_files
$IMAGE $MD5_FILE_FS
537 # Lets mount the image and test sb hostfs commands
538 mkdir
-p "$MOUNT_DIR"
539 if [ "$fs" = "fat" ]; then
544 sudo mount
-o loop
,rw
,$uid "$IMAGE" "$MOUNT_DIR"
545 sudo
chmod 777 "$MOUNT_DIR"
547 OUT_FILE
="${OUT}.sb.${fs}.out"
548 test_image
$IMAGE $fs $SMALL_FILE $BIG_FILE sb
`pwd`/$MOUNT_DIR \
550 sudo umount
"$MOUNT_DIR"
553 check_results
$OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE
554 TOTAL_FAIL
=$
((TOTAL_FAIL
+ FAIL
))
555 TOTAL_PASS
=$
((TOTAL_PASS
+ PASS
))
556 echo "Summary: PASS: $PASS FAIL: $FAIL"
557 echo "--------------------------------------------"
563 echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
564 echo "--------------------------------------------"
565 if [ $TOTAL_FAIL -eq 0 ]; then