blob: a4fb0559625d07ff24bed8224f6d53da2ec29280 [file] [log] [blame]
Suriyan Ramasami6c016482014-11-17 14:39:39 -08001#!/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.
22PREREQ_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.
26OUT_DIR="sandbox/test/fs"
27
28# Location of generated sandbox u-boot
29UBOOT="./sandbox/u-boot"
30
31# Our mount directory will be in the sandbox
32MOUNT_DIR="${OUT_DIR}/mnt"
33
34# The file system image we create will have the $IMG prefix.
35IMG="${OUT_DIR}/3GB"
36
37# $SMALL_FILE is the name of the 1MB file in the file system image
38SMALL_FILE="1MB.file"
39
40# $BIG_FILE is the name of the 2.5GB file in the file system image
41BIG_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)
45MD5_FILE="${OUT_DIR}/md5s.list"
46
47# $OUT shall be the prefix of the test output. Their suffix will be .out
48OUT="${OUT_DIR}/fs-test"
49
50# Full Path of the 1 MB file that shall be created in the fs image.
51MB1="${MOUNT_DIR}/${SMALL_FILE}"
52GB2p5="${MOUNT_DIR}/${BIG_FILE}"
53
54# ************************
55# * Functions start here *
56# ************************
57
58# Check if the prereq binaries exist, or exit
59function 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
75function 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
84function 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
101function 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.
109function 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
129function 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
151function 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
211sb=$5
212setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
213run 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
222printenv filesize
223setenv filesize
224
225# 2.5GB (1024*1024*2500) is 0x9C40 0000
226# Test Case 3 - size of big file
227${PREFIX}size host${SUFFIX} $FILE_BIG
228printenv filesize
229setenv 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
237printenv filesize
238# Test Case 4b - Read full 1MB of small file
239md5sum $addr \$filesize
240setenv filesize
241
242# Test Case 5a - First 1MB of big file
243${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x0
244printenv filesize
245# Test Case 5b - First 1MB of big file
246md5sum $addr \$filesize
247setenv 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
252printenv filesize
253# Test Case 6b - Last 1MB of big file
254md5sum $addr \$filesize
255setenv 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
260printenv filesize
261# Test Case 7b - One from the last 1MB chunk of 2GB
262md5sum $addr \$filesize
263setenv 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
268printenv filesize
269# Test Case 8b - One from the start 1MB chunk from 2GB
270md5sum $addr \$filesize
271setenv 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
276printenv filesize
277# Test Case 9b - One 1MB chunk crossing the 2GB boundary
278md5sum $addr \$filesize
279setenv 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
284printenv 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
292mw.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
295md5sum $addr \$filesize
296setenv filesize
297#
298reset
299
300EOF
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.
310function 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
370function 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
387check_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.
413function 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.
484function 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
503check_clean "$1"
504check_prereq
505compile_sandbox
506prepare_env
507
508# Track TOTAL_FAIL and TOTAL_PASS
509TOTAL_FAIL=0
510TOTAL_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.
515for 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
551done
552
553echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
554echo "--------------------------------------------"
555if [ $TOTAL_FAIL -eq 0 ]; then
556 echo "PASSED"
557 exit 0
558else
559 echo "FAILED"
560 exit 1
561fi