Merge patch series "fs: exfat: Add exfat port based on exfat-fuse"

Marek Vasut <marex@denx.de> says:

Import exfat-fuse libexfat, add U-Boot filesystem layer porting glue
code and wire exfat support into generic filesystem support code. This
adds exfat support to U-Boot.

Fill in generic filesystem interface for mkdir and rm commands.
Make filesystem tests test the generic interface as well as exfat,
to make sure this code does not fall apart.

Link: https://github.com/relan/exfat/commits/0b41c6d3560d ("CI: bump FreeBSD to 13.1.")
Link: https://lore.kernel.org/r/20250317031418.223019-1-marex@denx.de

1 files changed, 36 insertions, 35 deletions

diff --git a/test/py/tests/test_fs/test_basic.py b/test/py/tests/test_fs/test_basic.py
index 5a02348bb94..64a3b50f52a 100644
--- a/test/py/tests/test_fs/test_basic.py
+++ b/test/py/tests/test_fs/test_basic.py
@@ -20,32 +20,32 @@ class TestFsBasic(object):
         """
         Test Case 1 - ls command, listing a root directory and invalid directory
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 1a - ls'):
             # Test Case 1 - ls
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%sls host 0:0' % fs_type])
+                '%sls host 0:0' % fs_cmd_prefix])
             assert(re.search('2621440000 *%s' % BIG_FILE, ''.join(output)))
             assert(re.search('1048576 *%s' % SMALL_FILE, ''.join(output)))
 
         with ubman.log.section('Test Case 1b - ls (invalid dir)'):
             # In addition, test with a nonexistent directory to see if we crash.
             output = ubman.run_command(
-                '%sls host 0:0 invalid_d' % fs_type)
+                '%sls host 0:0 invalid_d' % fs_cmd_prefix)
             assert('' == output)
 
     def test_fs2(self, ubman, fs_obj_basic):
         """
         Test Case 2 - size command for a small file
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 2a - size (small)'):
             # 1MB is 0x0010 0000
             # Test Case 2a - size of small file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%ssize host 0:0 /%s' % (fs_type, SMALL_FILE),
+                '%ssize host 0:0 /%s' % (fs_cmd_prefix, SMALL_FILE),
                 'printenv filesize',
                 'setenv filesize'])
             assert('filesize=100000' in ''.join(output))
@@ -53,7 +53,7 @@ class TestFsBasic(object):
         with ubman.log.section('Test Case 2b - size (/../<file>)'):
             # Test Case 2b - size of small file via a path using '..'
             output = ubman.run_command_list([
-                '%ssize host 0:0 /SUBDIR/../%s' % (fs_type, SMALL_FILE),
+                '%ssize host 0:0 /SUBDIR/../%s' % (fs_cmd_prefix, SMALL_FILE),
                 'printenv filesize',
                 'setenv filesize'])
             assert('filesize=100000' in ''.join(output))
@@ -62,13 +62,13 @@ class TestFsBasic(object):
         """
         Test Case 3 - size command for a large file
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 3 - size (large)'):
             # 2.5GB (1024*1024*2500) is 0x9C40 0000
             # Test Case 3 - size of big file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%ssize host 0:0 /%s' % (fs_type, BIG_FILE),
+                '%ssize host 0:0 /%s' % (fs_cmd_prefix, BIG_FILE),
                 'printenv filesize',
                 'setenv filesize'])
             assert('filesize=9c400000' in ''.join(output))
@@ -77,12 +77,12 @@ class TestFsBasic(object):
         """
         Test Case 4 - load a small file, 1MB
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 4 - load (small)'):
             # Test Case 4a - Read full 1MB of small file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
+                '%sload host 0:0 %x /%s' % (fs_cmd_prefix, ADDR, SMALL_FILE),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -96,12 +96,12 @@ class TestFsBasic(object):
         """
         Test Case 5 - load, reading first 1MB of 3GB file
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 5 - load (first 1MB)'):
             # Test Case 5a - First 1MB of big file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%sload host 0:0 %x /%s %x 0x0' % (fs_type, ADDR, BIG_FILE, LENGTH),
+                '%sload host 0:0 %x /%s %x 0x0' % (fs_cmd_prefix, ADDR, BIG_FILE, LENGTH),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -115,14 +115,14 @@ class TestFsBasic(object):
         """
         Test Case 6 - load, reading last 1MB of 3GB file
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 6 - load (last 1MB)'):
             # fails for ext as no offset support
             # Test Case 6a - Last 1MB of big file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
                 '%sload host 0:0 %x /%s %x 0x9c300000'
-                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                    % (fs_cmd_prefix, ADDR, BIG_FILE, LENGTH),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -136,14 +136,14 @@ class TestFsBasic(object):
         """
         Test Case 7 - load, 1MB from the last 1MB in 2GB
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 7 - load (last 1MB in 2GB)'):
             # fails for ext as no offset support
             # Test Case 7a - One from the last 1MB chunk of 2GB
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
                 '%sload host 0:0 %x /%s %x 0x7ff00000'
-                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                    % (fs_cmd_prefix, ADDR, BIG_FILE, LENGTH),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -157,14 +157,14 @@ class TestFsBasic(object):
         """
         Test Case 8 - load, reading first 1MB in 2GB
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 8 - load (first 1MB in 2GB)'):
             # fails for ext as no offset support
             # Test Case 8a - One from the start 1MB chunk from 2GB
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
                 '%sload host 0:0 %x /%s %x 0x80000000'
-                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                    % (fs_cmd_prefix, ADDR, BIG_FILE, LENGTH),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -178,14 +178,14 @@ class TestFsBasic(object):
         """
         Test Case 9 - load, 1MB crossing 2GB boundary
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 9 - load (crossing 2GB boundary)'):
             # fails for ext as no offset support
             # Test Case 9a - One 1MB chunk crossing the 2GB boundary
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
                 '%sload host 0:0 %x /%s %x 0x7ff80000'
-                    % (fs_type, ADDR, BIG_FILE, LENGTH),
+                    % (fs_cmd_prefix, ADDR, BIG_FILE, LENGTH),
                 'printenv filesize'])
             assert('filesize=100000' in ''.join(output))
 
@@ -199,14 +199,14 @@ class TestFsBasic(object):
         """
         Test Case 10 - load, reading beyond file end'):
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 10 - load (beyond file end)'):
             # Generic failure case
             # Test Case 10 - 2MB chunk from the last 1MB of big file
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
                 '%sload host 0:0 %x /%s 0x00200000 0x9c300000'
-                    % (fs_type, ADDR, BIG_FILE),
+                    % (fs_cmd_prefix, ADDR, BIG_FILE),
                 'printenv filesize',
                 'md5sum %x $filesize' % ADDR,
                 'setenv filesize'])
@@ -216,22 +216,22 @@ class TestFsBasic(object):
         """
         Test Case 11 - write'
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 11 - write'):
             # Read 1MB from small file
             # Write it back to test the writes
             # Test Case 11a - Check that the write succeeded
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
-                '%swrite host 0:0 %x /%s.w $filesize'
-                    % (fs_type, ADDR, SMALL_FILE)])
+                '%sload host 0:0 %x /%s' % (fs_cmd_prefix, ADDR, SMALL_FILE),
+                '%s%s host 0:0 %x /%s.w $filesize'
+                    % (fs_cmd_prefix, fs_cmd_write, ADDR, SMALL_FILE)])
             assert('1048576 bytes written' in ''.join(output))
 
             # Test Case 11b - Check md5 of written to is same
             # as the one read from
             output = ubman.run_command_list([
-                '%sload host 0:0 %x /%s.w' % (fs_type, ADDR, SMALL_FILE),
+                '%sload host 0:0 %x /%s.w' % (fs_cmd_prefix, ADDR, SMALL_FILE),
                 'md5sum %x $filesize' % ADDR,
                 'setenv filesize'])
             assert(md5val[0] in ''.join(output))
@@ -241,7 +241,7 @@ class TestFsBasic(object):
         """
         Test Case 12 - write to "." directory
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 12 - write (".")'):
             # Next test case checks writing a file whose dirent
             # is the first in the block, which is always true for "."
@@ -249,7 +249,8 @@ class TestFsBasic(object):
             # Test Case 12 - Check directory traversal
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%swrite host 0:0 %x /. 0x10' % (fs_type, ADDR)])
+                '%s%s host 0:0 %x /. 0x10'
+                    % (fs_cmd_prefix, fs_cmd_write, ADDR)])
             assert('Unable to write' in ''.join(output))
             assert_fs_integrity(fs_type, fs_img)
 
@@ -257,23 +258,23 @@ class TestFsBasic(object):
         """
         Test Case 13 - write to a file with "/./<filename>"
         """
-        fs_type,fs_img,md5val = fs_obj_basic
+        fs_type,fs_cmd_prefix,fs_cmd_write,fs_img,md5val = fs_obj_basic
         with ubman.log.section('Test Case 13 - write  ("./<file>")'):
             # Read 1MB from small file
             # Write it via "same directory", i.e. "." dirent
             # Test Case 13a - Check directory traversal
             output = ubman.run_command_list([
                 'host bind 0 %s' % fs_img,
-                '%sload host 0:0 %x /%s' % (fs_type, ADDR, SMALL_FILE),
-                '%swrite host 0:0 %x /./%s2 $filesize'
-                    % (fs_type, ADDR, SMALL_FILE)])
+                '%sload host 0:0 %x /%s' % (fs_cmd_prefix, ADDR, SMALL_FILE),
+                '%s%s host 0:0 %x /./%s2 $filesize'
+                    % (fs_cmd_prefix, fs_cmd_write, ADDR, SMALL_FILE)])
             assert('1048576 bytes written' in ''.join(output))
 
             # Test Case 13b - Check md5 of written to is same
             # as the one read from
             output = ubman.run_command_list([
                 'mw.b %x 00 100' % ADDR,
-                '%sload host 0:0 %x /./%s2' % (fs_type, ADDR, SMALL_FILE),
+                '%sload host 0:0 %x /./%s2' % (fs_cmd_prefix, ADDR, SMALL_FILE),
                 'md5sum %x $filesize' % ADDR,
                 'setenv filesize'])
             assert(md5val[0] in ''.join(output))
@@ -282,7 +283,7 @@ class TestFsBasic(object):
             # as the one read from
             output = ubman.run_command_list([
                 'mw.b %x 00 100' % ADDR,
-                '%sload host 0:0 %x /%s2' % (fs_type, ADDR, SMALL_FILE),
+                '%sload host 0:0 %x /%s2' % (fs_cmd_prefix, ADDR, SMALL_FILE),
                 'md5sum %x $filesize' % ADDR,
                 'setenv filesize'])
             assert(md5val[0] in ''.join(output))