fix: support fat32 on 4k native disks (#316)

This fixes the issue that `GetFilesystem()` fails on vfat created on disks with 4k sector size.
`mkfs.vfat` uses 4k size when disk is native 4k.

This can be reproduced by creating a loopback device with 4k sectors and running mkfs.vfat on it.

```bash
truncate -s 10M /tmp/vfat_4k.img

sudo losetup -f --show -b 4096 /tmp/vfat_4k.img

sudo mkfs.vfat -F 32 -n TEST4K /dev/loop0

sudo losetup -d /dev/loop0
```

Then can be tested as:

```go
package main

import (
	"github.com/diskfs/go-diskfs"
	"github.com/diskfs/go-diskfs/backend/file"
	"github.com/stretchr/testify/require"
)

func main() {
	// Open the image file created with 4K sectors
	bk, err := file.OpenFromPath("/tmp/vfat_4k.img", false)
	require.NoError(err, "failed to open image file")

	defer bk.Close()

	// Try to open the disk
	diskInfo, err := diskfs.OpenBackend(bk, diskfs.WithOpenMode(diskfs.ReadWriteExclusive))
	require.NoError(err, "failed to open backend")

	defer diskInfo.Close()

	// This will fail with unpatched go-diskfs:
	// "unknown filesystem on partition 0"
	// Because go-diskfs rejects bytesPerSector != 512
	fs, err := diskInfo.GetFilesystem(0)
	require.NoError(err, "failed to get filesystem from partition 0")

	defer fs.Close()
}
```

When mkfs.vfat formats a device with 4K logical sectors, it writes bytesPerSector=4096 in the BPB, which go-diskfs rejects.

Signed-off-by: Noel Georgi <[email protected]>

Author: frezbo

filesystem/fat32/common_test.go

@@ -15,6 +15,7 @@ import (
 
 const (
 	Fat32File           = "./testdata/dist/fat32.img"
+	Fat32File4kB        = "./testdata/dist/fat32-4k.img"
 	fsckFile            = "./testdata/dist/fsck.txt"
 	rootdirFile         = "./testdata/dist/root_dir.txt"
 	rootdirFileFLS      = "./testdata/dist/root_dir_fls.txt"
@@ -199,9 +200,7 @@ func testGetValidDirectoryEntriesFromFile(dirFilePath, dirEntryPattern string, f
 		text := scanner.Text()
 		dirEntryMatch := testDirectoryEntryRE.FindStringSubmatch(text)
 		fileEntryMatch := testFileEntryRE.FindStringSubmatch(text)
-		var (
-			de *directoryEntry
-		)
+		var de *directoryEntry
 		switch {
 		case len(dirEntryMatch) == 4:
 			filenameShort := dirEntryMatch[1]

filesystem/fat32/dos20bpb.go

@@ -25,11 +25,13 @@ func dos20BPBFromBytes(b []byte) (*dos20BPB, error) {
 	}
 	bpb := dos20BPB{}
 	// make sure we have a valid sector size
+	// Modern mkfs.vfat creates FAT32 with larger sector sizes on 4K native disks
+	// Accept any power-of-2 sector size >= 512
 	sectorSize := binary.LittleEndian.Uint16(b[0:2])
-	if sectorSize != uint16(SectorSize512) {
-		return nil, fmt.Errorf("invalid sector size %d provided in DOS 2.0 BPB. Must be %d", sectorSize, SectorSize512)
+	if sectorSize < uint16(SectorSize512) || (sectorSize&(sectorSize-1)) != 0 {
+		return nil, fmt.Errorf("invalid sector size %d provided in DOS 2.0 BPB. Must be power of 2 and >= %d", sectorSize, SectorSize512)
 	}
-	bpb.bytesPerSector = SectorSize512
+	bpb.bytesPerSector = SectorSize(sectorSize)
 	bpb.sectorsPerCluster = b[2]
 	bpb.reservedSectors = binary.LittleEndian.Uint16(b[3:5])
 	bpb.fatCount = b[5]

filesystem/fat32/fat32.go

@@ -341,30 +341,36 @@ func Read(b backend.Storage, size, start, blocksize int64) (*FileSystem, error)
 		return nil, fmt.Errorf("requested size is smaller than minimum allowed FAT32 size %d", blocksize*4)
 	}
 	// load the information from the disk
-	// read first 512 bytes from the file
-	bsb := make([]byte, SectorSize512)
+	// We need to read at least the first logical sector to get the BPB
+	// Try reading up to 4096 bytes to handle 4K sector devices
+	maxSectorSize := 4096
+	bsb := make([]byte, maxSectorSize)
 	n, err := b.ReadAt(bsb, start)
 	if err != nil {
 		return nil, fmt.Errorf("could not read bytes from file: %w", err)
 	}
-	if uint16(n) < uint16(SectorSize512) {
-		return nil, fmt.Errorf("only could read %d bytes from file", n)
+	if n < int(SectorSize512) {
+		return nil, fmt.Errorf("only could read %d bytes from file, need at least %d", n, SectorSize512)
 	}
-	bs, err := msDosBootSectorFromBytes(bsb)
 
+	// Parse boot sector from the first 512 bytes (boot sector structure is always 512 bytes)
+	bs, err := msDosBootSectorFromBytes(bsb[:SectorSize512])
 	if err != nil {
 		return nil, fmt.Errorf("error reading MS-DOS Boot Sector: %w", err)
 	}
 
+	// Get the actual sector size from the BPB
+	bytesPerSector := bs.biosParameterBlock.dos331BPB.dos20BPB.bytesPerSector
 	sectorsPerFat := bs.biosParameterBlock.sectorsPerFat
-	fatSize := sectorsPerFat * uint32(SectorSize512)
+	fatSize := sectorsPerFat * uint32(bytesPerSector)
 	reservedSectors := bs.biosParameterBlock.dos331BPB.dos20BPB.reservedSectors
 	sectorsPerCluster := bs.biosParameterBlock.dos331BPB.dos20BPB.sectorsPerCluster
-	fatPrimaryStart := uint64(reservedSectors) * uint64(SectorSize512)
+	fatPrimaryStart := uint64(reservedSectors) * uint64(bytesPerSector)
 	fatSecondaryStart := fatPrimaryStart + uint64(fatSize)
 
+	// FSI sector is always 512 bytes
 	fsisBytes := make([]byte, 512)
-	read, err := b.ReadAt(fsisBytes, int64(bs.biosParameterBlock.fsInformationSector)*blocksize+start)
+	read, err := b.ReadAt(fsisBytes, int64(bs.biosParameterBlock.fsInformationSector)*int64(bytesPerSector)+start)
 	if err != nil {
 		return nil, fmt.Errorf("unable to read bytes for FSInformationSector: %w", err)
 	}
@@ -392,7 +398,7 @@ func Read(b backend.Storage, size, start, blocksize int64) (*FileSystem, error)
 		fsis:            *fsis,
 		table:           *fat,
 		dataStart:       dataStart,
-		bytesPerCluster: int(sectorsPerCluster) * int(SectorSize512),
+		bytesPerCluster: int(sectorsPerCluster) * int(bytesPerSector),
 		start:           start,
 		size:            size,
 		backend:         b,
@@ -994,7 +1000,6 @@ func (fs *FileSystem) mkLabel(parent *Directory, name string) (*directoryEntry,
 // if it does not exist, it may or may not make it
 func (fs *FileSystem) readDirWithMkdir(p string, doMake bool) (*Directory, []*directoryEntry, error) {
 	paths, err := splitPath(p)
-
 	if err != nil {
 		return nil, nil, err
 	}

filesystem/fat32/fat32_test.go

@@ -111,6 +111,25 @@ func TestFat32Type(t *testing.T) {
 	}
 }
 
+func TestFat32With4kSectors(t *testing.T) {
+	bk, err := file.OpenFromPath(fat32.Fat32File4kB, true)
+	if err != nil {
+		t.Fatalf("Failed to open file with 4k sectors: %v", err)
+	}
+
+	d, err := diskfs.OpenBackend(bk)
+	if err != nil {
+		t.Fatalf("Failed to open disk with 4k sectors: %v", err)
+	}
+
+	defer d.Close()
+
+	_, err = d.GetFilesystem(0)
+	if err != nil {
+		t.Fatalf("Failed to get filesystem with 4k sectors: %v", err)
+	}
+}
+
 func TestFat32Mkdir(t *testing.T) {
 	// only do this test if os.Getenv("TEST_IMAGE") contains a real image
 	if intImage == "" {
@@ -1249,7 +1268,6 @@ func Test_Rename(t *testing.T) {
 				// do not create orig file
 			},
 			post: func(_ *testing.T, _ *fat32.FileSystem) {
-
 			},
 		},
 		{
@@ -1406,7 +1424,6 @@ func Test_Remove(t *testing.T) {
 				// do not create any file
 			},
 			post: func(_ *testing.T, _ *fat32.FileSystem) {
-
 			},
 		},
 		{

filesystem/fat32/testdata/mkfat32.sh

@@ -16,6 +16,8 @@ set -x
 apk --update add dosfstools mtools sleuthkit
 dd if=/dev/zero of=/data/fat32.img bs=1M count=10
 mkfs.vfat -v -F 32 /data/fat32.img
+dd if=/dev/zero of=/data/fat32-4k.img bs=1M count=10
+mkfs.vfat -v -F 32 -S 4096 /data/fat32-4k.img
 echo "mtools_skip_check=1" >> /etc/mtools.conf
 mmd -i /data/fat32.img ::/foo
 mmd -i /data/fat32.img ::/foo/bar