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. 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 562