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