fix: work around LLVM -O2 miscompilation of lfs_dir_fetchmatch

LLVM's ThinLTO at -O2 miscompiles lfs_dir_fetchmatch(), causing directory metadata scans to return incorrect results. mkdir succeeds but subsequent stat/open fails with 'no directory entry'. The bug does not appear at -Oz (TinyGo's default), which is why the earlier Sync() approach seemed to help.

Add __attribute__((optnone)) to lfs_dir_fetchmatch to prevent the miscompilation. Targeted approaches (volatile, noinline, memory barriers) were tested but none work - the issue is in how -O2 transforms the function's complex control flow as a whole.

- littlefs/lfs.c: optnone on lfs_dir_fetchmatch, revert cache fix - littlefs/go_lfs.go: revert Sync() calls (not the actual fix) - littlefs/go_lfs_callbacks.go: fix uint32 size parameter - littlefs/go_lfs_test.go: directory persistence tests - examples/sd_mkdir_test/: hardware test firmware for SD card

Author: marcelfarres

examples/sd_mkdir_test/main.go

@@ -186,48 +186,24 @@ func (l *LFS) Mount() error {
 }
 
 func (l *LFS) Format() error {
-	if err := errval(C.lfs_format(l.lfs, l.cfg)); err != nil {
-		return err
-	}
-	if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_format(l.lfs, l.cfg))
 }
 
 func (l *LFS) Unmount() error {
-	if err := errval(C.lfs_unmount(l.lfs)); err != nil {
-		return err
-	}
-	if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_unmount(l.lfs))
 }
 
 func (l *LFS) Remove(path string) error {
 	cs := cstring(path)
 	defer C.free(unsafe.Pointer(cs))
-	if err := errval(C.lfs_remove(l.lfs, cs)); err != nil {
-		return err
-	}
-	if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_remove(l.lfs, cs))
 }
 
 func (l *LFS) Rename(oldPath string, newPath string) error {
 	cs1, cs2 := cstring(oldPath), cstring(newPath)
 	defer C.free(unsafe.Pointer(cs1))
 	defer C.free(unsafe.Pointer(cs2))
-	if err := errval(C.lfs_rename(l.lfs, cs1, cs2)); err != nil {
-		return err
-	}
-	if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_rename(l.lfs, cs1, cs2))
 }
 
 func (l *LFS) Stat(path string) (os.FileInfo, error) {
@@ -247,13 +223,7 @@ func (l *LFS) Stat(path string) (os.FileInfo, error) {
 func (l *LFS) Mkdir(path string, _ os.FileMode) error {
 	cs := (*C.char)(cstring(path))
 	defer C.free(unsafe.Pointer(cs))
-	if err := errval(C.lfs_mkdir(l.lfs, cs)); err != nil {
-		return err
-	}
-	if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_mkdir(l.lfs, cs))
 }
 
 func (l *LFS) Open(path string) (tinyfs.File, error) {
@@ -291,24 +261,6 @@ func (l *LFS) OpenFile(path string, flags int) (tinyfs.File, error) {
 		return nil, err
 	}
 
-	if flags&(os.O_CREATE|os.O_TRUNC) != 0 {
-		if flags&os.O_TRUNC != 0 {
-			if err := errval(C.lfs_file_sync(l.lfs, file.fileptr())); err != nil {
-				file.Close()
-				return nil, err
-			}
-		}
-		if syncer, ok := l.dev.(tinyfs.Syncer); ok {
-			if err := syncer.Sync(); err != nil {
-				// Should we close and return error?
-				// Maybe just log? But we can't log.
-				// For now let's just return error and close.
-				file.Close()
-				return nil, err
-			}
-		}
-	}
-
 	return file, nil
 }
 
@@ -353,21 +305,14 @@ func (f *File) Close() error {
 			C.free(f.hndl)
 			f.hndl = nil
 		}()
-		var err error
 		switch f.typ {
 		case fileTypeReg:
-			err = errval(C.lfs_file_close(f.lfs.lfs, f.fileptr()))
+			return errval(C.lfs_file_close(f.lfs.lfs, f.fileptr()))
 		case fileTypeDir:
-			err = errval(C.lfs_dir_close(f.lfs.lfs, f.dirptr()))
+			return errval(C.lfs_dir_close(f.lfs.lfs, f.dirptr()))
 		default:
 			panic("lfs: unknown typ for file handle")
 		}
-		if err != nil {
-			return err
-		}
-		if syncer, ok := f.lfs.dev.(tinyfs.Syncer); ok {
-			return syncer.Sync()
-		}
 	}
 	return nil
 }
@@ -428,27 +373,12 @@ func (f *File) Stat() (os.FileInfo, error) {
 
 // Sync synchronizes to storage so that any pending writes are written out.
 func (f *File) Sync() error {
-	if err := errval(C.lfs_file_sync(f.lfs.lfs, f.fileptr())); err != nil {
-		return err
-	}
-	if syncer, ok := f.lfs.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_file_sync(f.lfs.lfs, f.fileptr()))
 }
 
 // Truncate the size of the file to the specified size
 func (f *File) Truncate(size uint32) error {
-	if err := errval(C.lfs_file_truncate(f.lfs.lfs, f.fileptr(), C.lfs_off_t(size))); err != nil {
-		return err
-	}
-	if err := errval(C.lfs_file_sync(f.lfs.lfs, f.fileptr())); err != nil {
-		return err
-	}
-	if syncer, ok := f.lfs.dev.(tinyfs.Syncer); ok {
-		return syncer.Sync()
-	}
-	return nil
+	return errval(C.lfs_file_truncate(f.lfs.lfs, f.fileptr(), C.lfs_off_t(size)))
 }
 
 func (f *File) Write(buf []byte) (n int, err error) {

littlefs/go_lfs.go

@@ -15,7 +15,7 @@ const (
 )
 
 //export go_lfs_block_device_read
-func go_lfs_block_device_read(ctx unsafe.Pointer, block uint32, offset uint32, buf unsafe.Pointer, size int) int {
+func go_lfs_block_device_read(ctx unsafe.Pointer, block uint32, offset uint32, buf unsafe.Pointer, size uint32) int {
 	if debug {
 		fmt.Printf("go_lfs_block_device_read: %v, %v, %v, %v, %v\n", ctx, block, offset, buf, size)
 	}
@@ -27,7 +27,7 @@ func go_lfs_block_device_read(ctx unsafe.Pointer, block uint32, offset uint32, b
 }
 
 //export go_lfs_block_device_prog
-func go_lfs_block_device_prog(ctx unsafe.Pointer, block uint32, offset uint32, buf unsafe.Pointer, size int) int {
+func go_lfs_block_device_prog(ctx unsafe.Pointer, block uint32, offset uint32, buf unsafe.Pointer, size uint32) int {
 	if debug {
 		fmt.Printf("go_lfs_block_device_prog: %v, %v, %v, %v, %v\n", ctx, block, offset, buf, size)
 	}

littlefs/go_lfs_callbacks.go

@@ -397,3 +397,187 @@ func TestDirectoryPersistence(t *testing.T) {
 		t.Fatalf("'%s' exists but is not a directory", dirName)
 	}
 }
+
+// TestDirectoryWithFiles tests creating directories and adding files to them.
+// This covers the common use case of organizing files in subdirectories.
+func TestDirectoryWithFiles(t *testing.T) {
+	fs, _, unmount := createTestFS(t, defaultConfig)
+	defer unmount()
+
+	t.Run("CreateDirAndAddFile", func(t *testing.T) {
+		// Create a directory
+		check(t, fs.Mkdir("mydir", 0777))
+
+		// Create a file inside the directory
+		f, err := fs.OpenFile("mydir/test.txt", os.O_CREATE|os.O_WRONLY)
+		check(t, err)
+		
+		content := []byte("Hello from inside a directory!")
+		n, err := f.Write(content)
+		check(t, err)
+		if n != len(content) {
+			t.Fatalf("expected to write %d bytes, wrote %d", len(content), n)
+		}
+		check(t, f.Close())
+
+		// Read back and verify
+		f, err = fs.Open("mydir/test.txt")
+		check(t, err)
+		buf := make([]byte, 100)
+		n, err = f.Read(buf)
+		check(t, err)
+		if string(buf[:n]) != string(content) {
+			t.Fatalf("content mismatch: got %q, want %q", string(buf[:n]), string(content))
+		}
+		check(t, f.Close())
+	})
+
+	t.Run("MultipleFilesInDir", func(t *testing.T) {
+		check(t, fs.Mkdir("multidir", 0777))
+		
+		files := []string{"file1.txt", "file2.txt", "file3.txt"}
+		for _, fname := range files {
+			path := "multidir/" + fname
+			f, err := fs.OpenFile(path, os.O_CREATE|os.O_WRONLY)
+			check(t, err)
+			_, err = f.Write([]byte("content of " + fname))
+			check(t, err)
+			check(t, f.Close())
+		}
+
+		// Verify all files exist
+		for _, fname := range files {
+			path := "multidir/" + fname
+			info, err := fs.Stat(path)
+			check(t, err)
+			if info.IsDir() {
+				t.Fatalf("expected file, got directory: %s", path)
+			}
+		}
+	})
+
+	t.Run("NestedDirsWithFiles", func(t *testing.T) {
+		// Create nested directory structure
+		check(t, fs.Mkdir("level1", 0777))
+		check(t, fs.Mkdir("level1/level2", 0777))
+		check(t, fs.Mkdir("level1/level2/level3", 0777))
+
+		// Add files at each level
+		levels := []string{"level1", "level1/level2", "level1/level2/level3"}
+		for _, dir := range levels {
+			path := dir + "/data.txt"
+			f, err := fs.OpenFile(path, os.O_CREATE|os.O_WRONLY)
+			check(t, err)
+			_, err = f.Write([]byte("data at " + dir))
+			check(t, err)
+			check(t, f.Close())
+		}
+
+		// Verify all files
+		for _, dir := range levels {
+			path := dir + "/data.txt"
+			info, err := fs.Stat(path)
+			check(t, err)
+			if info.IsDir() {
+				t.Fatalf("expected file, got directory: %s", path)
+			}
+			if info.Size() == 0 {
+				t.Fatalf("file %s has zero size", path)
+			}
+		}
+	})
+}
+
+// TestDirectoryFilePersistence tests that files in directories persist after unmount/remount.
+func TestDirectoryFilePersistence(t *testing.T) {
+	bd := tinyfs.NewMemoryDevice(testPageSize, testBlockSize, testBlockCount)
+	fs := New(bd).Configure(defaultConfig)
+
+	check(t, fs.Format())
+	check(t, fs.Mount())
+
+	// Create directory and file
+	check(t, fs.Mkdir("persist_dir", 0777))
+	
+	f, err := fs.OpenFile("persist_dir/important.txt", os.O_CREATE|os.O_WRONLY)
+	check(t, err)
+	content := []byte("This data must survive remount!")
+	_, err = f.Write(content)
+	check(t, err)
+	check(t, f.Close())
+
+	// Unmount
+	check(t, fs.Unmount())
+
+	// Remount with new instance
+	fs2 := New(bd).Configure(defaultConfig)
+	check(t, fs2.Mount())
+	defer fs2.Unmount()
+
+	// Verify directory exists
+	dirInfo, err := fs2.Stat("persist_dir")
+	if err != nil {
+		t.Fatalf("directory lost after remount: %v", err)
+	}
+	if !dirInfo.IsDir() {
+		t.Fatalf("persist_dir is not a directory")
+	}
+
+	// Verify file exists and has correct content
+	f, err = fs2.Open("persist_dir/important.txt")
+	if err != nil {
+		t.Fatalf("file lost after remount: %v", err)
+	}
+	defer f.Close()
+
+	buf := make([]byte, 100)
+	n, err := f.Read(buf)
+	check(t, err)
+	if string(buf[:n]) != string(content) {
+		t.Fatalf("content corrupted after remount: got %q, want %q", string(buf[:n]), string(content))
+	}
+}
+
+// TestDeepNestedDirectories tests creating deeply nested directories and files.
+func TestDeepNestedDirectories(t *testing.T) {
+	fs, _, unmount := createTestFS(t, defaultConfig)
+	defer unmount()
+
+	// Create a deeply nested path
+	path := "a/b/c/d/e/f/g"
+	dirs := []string{"a", "a/b", "a/b/c", "a/b/c/d", "a/b/c/d/e", "a/b/c/d/e/f", "a/b/c/d/e/f/g"}
+	
+	for _, dir := range dirs {
+		check(t, fs.Mkdir(dir, 0777))
+	}
+
+	// Create file at the deepest level
+	filePath := path + "/deep_file.txt"
+	f, err := fs.OpenFile(filePath, os.O_CREATE|os.O_WRONLY)
+	check(t, err)
+	content := []byte("This is a deeply nested file")
+	_, err = f.Write(content)
+	check(t, err)
+	check(t, f.Close())
+
+	// Verify file
+	info, err := fs.Stat(filePath)
+	check(t, err)
+	if info.IsDir() {
+		t.Fatalf("expected file, got directory")
+	}
+	if info.Size() != int64(len(content)) {
+		t.Fatalf("expected size %d, got %d", len(content), info.Size())
+	}
+
+	// Read and verify content
+	f, err = fs.Open(filePath)
+	check(t, err)
+	buf := make([]byte, 100)
+	n, err := f.Read(buf)
+	check(t, err)
+	if string(buf[:n]) != string(content) {
+		t.Fatalf("content mismatch")
+	}
+	check(t, f.Close())
+}

littlefs/go_lfs_test.go

@@ -185,10 +185,6 @@ static int lfs_bd_flush(lfs_t *lfs,
             return err;
         }
 
-        if (pcache->block != LFS_BLOCK_NULL && pcache->block == rcache->block) {
-            lfs_cache_drop(lfs, rcache);
-        }
-
         if (validate) {
             // check data on disk
             lfs_cache_drop(lfs, rcache);
@@ -1073,7 +1069,11 @@ static int lfs_dir_traverse(lfs_t *lfs,
 }
 #endif
 
-static lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
+// Workaround for LLVM bug: this function gets miscompiled at -O2 and above,
+// causing directory metadata scans to return incorrect results (mkdir succeeds
+// but subsequent stat/open can't find the entry). Disabling optimization here
+// prevents the miscompilation while keeping the rest of lfs.c fully optimized.
+static __attribute__((optnone)) lfs_stag_t lfs_dir_fetchmatch(lfs_t *lfs,
         lfs_mdir_t *dir, const lfs_block_t pair[2],
         lfs_tag_t fmask, lfs_tag_t ftag, uint16_t *id,
         int (*cb)(void *data, lfs_tag_t tag, const void *buffer), void *data) {

littlefs/lfs.c

@@ -0,0 +1,2 @@
+builds/
+*.exe

tests/hw/.gitignore

@@ -0,0 +1,10 @@
+module tinygo.org/x/tinyfs/tests/hw
+
+go 1.25.7
+
+require go.bug.st/serial v1.6.4
+
+require (
+	github.com/creack/goselect v0.1.2 // indirect
+	golang.org/x/sys v0.19.0 // indirect
+)