Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
83 changes: 83 additions & 0 deletions internal/inode/inode_fuzz_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,83 @@
package inode

import (
"bytes"
"encoding/binary"
"testing"

"github.com/supporttools/GoClusterFS/internal/storage"
)

func FuzzDeserializeInode(f *testing.F) {
file := Inode{
Magic: InodeMagic,
InodeNum: 42,
Mode: S_IFREG | 0o644,
UID: 1000,
GID: 1000,
LinkCount: 1,
Size: 3 << 20,
AllocatedBlocks: 3,
WrittenBlocks: 3,
Atime: 1_700_000_000,
Mtime: 1_700_000_001,
Ctime: 1_700_000_002,
DataGeneration: 4,
MetaGeneration: 5,
LastModifierUUID: [16]byte{1, 2, 3, 4},
InlineExtents: [MaxInlineExtents]InlineExtent{
{LogicalBlock: 0, PhysicalBlock: 100, Length: 2, Flags: 1},
{LogicalBlock: 2, PhysicalBlock: 300, Length: 1, Flags: 1},
},
ExtentCount: 2,
}

tree := file
tree.Flags = FlagHasExtentTree
tree.ExtentTreeRoot = 999
tree.ExtentCount = ^uint64(0)
tree.ExtentDepth = ^uint32(0)
tree.Size = ^uint64(0)

sfb := file
sfb.Size = 100
sfb.ExtentCount = 1
sfb.InlineExtents = [MaxInlineExtents]InlineExtent{{PhysicalBlock: 7<<8 | 3, Length: 1, Flags: extentFlagSFB}}

root := Inode{Magic: InodeMagic, InodeNum: InodeRoot, Mode: S_IFDIR | 0o755, LinkCount: 2}

for _, ino := range []*Inode{&file, &tree, &sfb, &root} {
f.Add(serializeInode(ino))
}
valid := serializeInode(&file)
f.Add(valid[:InodeSize-1])
f.Add(valid[:4])
f.Add(make([]byte, InodeSize))
f.Add([]byte{})

f.Fuzz(func(t *testing.T, data []byte) {
checkInodeDecode(t, data)
if len(data) >= InodeSize {
fixed := bytes.Clone(data[:InodeSize])
binary.LittleEndian.PutUint32(fixed[InodeSize-4:], storage.CRC32C(fixed[:InodeSize-4]))
checkInodeDecode(t, fixed)
}
})
}

func checkInodeDecode(t *testing.T, data []byte) {
ino, err := deserializeInode(data)
if err != nil || ino.Magic == 0 {
return
}
_ = ino.IsSFBBacked()

again, err := deserializeInode(serializeInode(ino))
if err != nil {
t.Fatalf("decoding a re-encoded inode: %v", err)
}
again.Checksum, ino.Checksum = 0, 0
if *again != *ino {
t.Fatalf("inode changed after an encode/decode round trip")
}
}
246 changes: 246 additions & 0 deletions internal/journal/journal_fuzz_test.go
Original file line number Diff line number Diff line change
@@ -0,0 +1,246 @@
package journal

import (
"bytes"
"encoding/binary"
"runtime/metrics"
"strings"
"testing"
"time"

"github.com/supporttools/GoClusterFS/internal/storage"
)

const (
maxDecodeAlloc = 64 << 20
scanDataArea = 8 * storage.SectorSize
scanRegionSize = JournalDataOffset + scanDataArea
scanTimeout = 10 * time.Second
)

var fuzzNode = [16]byte{0xf0, 0x22}

func FuzzJournalSuperblock(f *testing.F) {
clean := NewJournalSuperblock(fuzzNode, 1, DefaultJournalSlotSize-JournalDataOffset)
f.Add(clean.Serialize())

dirty := *clean
dirty.State = JournalStateDirty
dirty.HeadOffset = 3 * storage.SectorSize
dirty.TailOffset = storage.SectorSize
dirty.WrapCount = 1
f.Add(dirty.Serialize())

maxed := *clean
maxed.State = JournalState(^uint32(0))
maxed.HeadOffset = ^uint32(0)
maxed.TailOffset = ^uint32(0)
maxed.DataAreaOffset = ^uint32(0)
maxed.DataAreaSize = 0
f.Add(maxed.Serialize())

valid := clean.Serialize()
f.Add(valid[:JournalSuperblockSize-1])
f.Add(make([]byte, JournalSuperblockSize))
f.Add([]byte{})

f.Fuzz(func(t *testing.T, data []byte) {
checkJournalSuperblockDecode(t, data)
if len(data) >= JournalSuperblockSize {
fixed := bytes.Clone(data[:JournalSuperblockSize])
binary.LittleEndian.PutUint32(fixed[JournalSuperblockSize-4:], storage.CRC32C(fixed[:JournalSuperblockSize-4]))
checkJournalSuperblockDecode(t, fixed)
}
})
}

func checkJournalSuperblockDecode(t *testing.T, data []byte) {
sb, err := DeserializeJournalSuperblock(data)
if err != nil {
return
}
_ = sb.AvailableSpace()

again, err := DeserializeJournalSuperblock(sb.Serialize())
if err != nil {
t.Fatalf("decoding a re-encoded journal superblock: %v", err)
}
if *again != *sb {
t.Fatalf("journal superblock changed after an encode/decode round trip")
}
}

func FuzzTxnRecord(f *testing.F) {
txn := seedTransaction(f, 5, 1)
f.Add(txn)
f.Add(txn[:len(txn)-1])
f.Add(txn[:TxnHeaderSize])
f.Add(txn[:TxnHeaderSize-1])
empty, err := NewTransaction(6, fuzzNode, 1).Serialize()
if err != nil {
f.Fatal(err)
}
f.Add(empty)
f.Add(NewIntentCompletion(5).Serialize())
f.Add([]byte{})

f.Fuzz(func(t *testing.T, data []byte) {
before := heapAllocBytes()

_, _ = DeserializeIntentCompletion(data)
_ = ValidateTxnChecksum(data)
_ = IterateEntries(data, func(_ *TxnEntry, payload []byte) error {
decodeAllPayloads(payload)
return nil
})
if header, err := DeserializeTxnHeader(data); err == nil {
if txn, err := parseTxnEntries(header, data); err == nil {
for _, e := range txn.Entries {
decodeAllPayloads(e.Payload)
}
}
}

if grown := heapAllocBytes() - before; grown > maxDecodeAlloc {
t.Fatalf("decoding a %d-byte record allocated %d bytes", len(data), grown)
}
})
}

func FuzzJournalScan(f *testing.F) {
dev, cleanup := createTestDevice(f, scanRegionSize)
f.Cleanup(cleanup)
img := storage.NewAlignedBuffer(scanRegionSize)

sector := func(n int) uint32 { return uint32(n * storage.SectorSize) }

multiSector := seedTransaction(f, 2, 40)
end := sector(2 + (len(multiSector)+storage.SectorSize-1)/storage.SectorSize)
linear := make([]byte, scanDataArea)
copy(linear[sector(0):], seedTransaction(f, 1, 1))
copy(linear[sector(1):], NewIntentCompletion(1).Serialize())
copy(linear[sector(2):], multiSector)
f.Add(uint32(0), end, uint32(scanDataArea), uint32(JournalDataOffset), linear)
f.Add(uint32(0), end-storage.SectorSize, uint32(scanDataArea), uint32(JournalDataOffset), linear)
f.Add(sector(2), sector(2), uint32(scanDataArea), uint32(JournalDataOffset), linear)

wrapped := make([]byte, scanDataArea)
copy(wrapped[sector(6):], seedTransaction(f, 3, 1))
copy(wrapped[sector(7):], NewIntentCompletion(3).Serialize())
copy(wrapped[sector(0):], seedTransaction(f, 4, 1))
f.Add(sector(6), sector(1), uint32(scanDataArea), uint32(JournalDataOffset), wrapped)

f.Add(uint32(0), sector(1), uint32(0), uint32(JournalDataOffset), linear)
f.Add(uint32(0), uint32(100), sector(1), uint32(JournalDataOffset), linear[sector(1):])
hugeTxn := bytes.Clone(linear)
binary.LittleEndian.PutUint32(hugeTxn[16:20], 1<<30)
f.Add(uint32(0), ^uint32(0)-storage.SectorSize+1, ^uint32(0)-storage.SectorSize+1, uint32(JournalDataOffset), hugeTxn)

f.Fuzz(func(t *testing.T, head, tail, size, dataOffset uint32, area []byte) {
sb := NewJournalSuperblock(fuzzNode, 1, size)
sb.State = JournalStateDirty
sb.HeadOffset, sb.TailOffset, sb.DataAreaOffset = head, tail, dataOffset

buf := img.Bytes()
clear(buf)
copy(buf, sb.Serialize())
copy(buf[JournalDataOffset:], area)
fixRecordChecksums(buf[JournalDataOffset:])
if _, err := dev.WriteAt(buf, 0); err != nil {
t.Fatal(err)
}

region, err := OpenRegionForRecovery(dev, 0, scanRegionSize)
if err != nil {
return
}

before := heapAllocBytes()
done := make(chan struct{})
go func() {
defer close(done)
txns, _, _ := DryRunRecover(region)
for _, txn := range txns {
for _, e := range txn.Entries {
decodeAllPayloads(e.Payload)
}
}
}()
select {
case <-done:
case <-time.After(scanTimeout):
t.Fatalf("recovery scan did not finish within %v", scanTimeout)
}

if grown := heapAllocBytes() - before; grown > maxDecodeAlloc {
t.Fatalf("recovery scan of a %d-byte region allocated %d bytes", scanRegionSize, grown)
}
})
}

func seedTransaction(tb testing.TB, seq uint64, dirEntries int) []byte {
tb.Helper()
txn := NewTransaction(seq, fuzzNode, 1)
for i := range dirEntries {
name := strings.Repeat(string(rune('a'+i%26)), 1+i*20%255)
if err := txn.LogDirAddEntry(&DirAddEntryPayload{ParentInodeNum: 2, ChildInodeNum: uint64(100 + i), EntryType: DirEntryRegular, Name: name}); err != nil {
tb.Fatal(err)
}
}
for _, err := range []error{
txn.LogInodeCreate(&InodeCreatePayload{InodeNum: 42, Mode: 0o100644, UID: 1000, GID: 1000, ParentInodeNum: 2, NameHash: 0xfeed}),
txn.LogDirRename(&DirRenamePayload{OldParentInodeNum: 2, NewParentInodeNum: 3, InodeNum: 42, EntryType: DirEntryRegular, OldName: "old.txt", NewName: "new-name.txt"}),
txn.LogExtentAdd(&ExtentAddPayload{InodeNum: 42, DiskBlock: 100, Length: 2, Flags: ExtentFlagWritten}),
txn.LogInodeDelete(&InodeDeletePayload{InodeNum: 42}),
} {
if err != nil {
tb.Fatal(err)
}
}
buf, err := txn.Serialize()
if err != nil {
tb.Fatal(err)
}
return buf
}

func fixRecordChecksums(area []byte) {
for off := 0; off+TxnHeaderSize <= len(area); off += storage.SectorSize {
rec := area[off:]
switch binary.LittleEndian.Uint32(rec) {
case TxnMagic:
n := int(binary.LittleEndian.Uint32(rec[16:20]))
if n >= TxnHeaderSize && n <= len(rec) {
binary.LittleEndian.PutUint32(rec[56:60], computeTxnChecksum(rec[:n]))
}
case IntentCompletionMagic:
crc := storage.CRC32CWithSeed(storage.CRC32C(rec[:20]), rec[24:32])
binary.LittleEndian.PutUint32(rec[20:24], crc)
}
}
}

func decodeAllPayloads(p []byte) {
_, _ = DeserializeInodeCreate(p)
_, _ = DeserializeInodeUpdate(p)
_, _ = DeserializeInodeDelete(p)
_, _ = DeserializeDirAddEntry(p)
_, _ = DeserializeDirRemoveEntry(p)
_, _ = DeserializeDirRename(p)
_, _ = DeserializeBlockAlloc(p)
_, _ = DeserializeBlockFree(p)
_, _ = DeserializeSFBAlloc(p)
_, _ = DeserializeSFBFree(p)
_, _ = DeserializeSFBMigrate(p)
_, _ = DeserializeExtentAdd(p)
_, _ = DeserializeExtentRemove(p)
_, _ = DeserializeSnapshotCreate(p)
_, _ = DeserializeSnapshotDelete(p)
_, _ = DeserializeRefCountUpdate(p)
}

func heapAllocBytes() uint64 {
s := []metrics.Sample{{Name: "/gc/heap/allocs:bytes"}}
metrics.Read(s)
return s[0].Value.Uint64()
}
4 changes: 2 additions & 2 deletions internal/journal/recovery.go
Original file line number Diff line number Diff line change
Expand Up @@ -330,7 +330,7 @@ func scanJournal(region *Region, handler RecoveryHandler, stats *RecoveryStats)
func parseTxnEntries(header *TxnHeader, buf []byte) (*RecoveredTxn, error) {
txn := &RecoveredTxn{
Header: header,
Entries: make([]*RecoveredEntry, 0, header.EntryCount),
Entries: make([]*RecoveredEntry, 0, min(header.EntryCount, uint32(len(buf)/TxnEntryHeaderSize))),
RawData: buf,
}

Expand All @@ -345,7 +345,7 @@ func parseTxnEntries(header *TxnHeader, buf []byte) (*RecoveredTxn, error) {
return nil, err
}

if offset+int(entry.Length) > len(buf) {
if entry.Length < TxnEntryHeaderSize || offset+int(entry.Length) > len(buf) {
return nil, ErrCorruptTxn
}

Expand Down
7 changes: 7 additions & 0 deletions internal/journal/region.go
Original file line number Diff line number Diff line change
Expand Up @@ -123,6 +123,13 @@ func (r *Region) readSuperblock() error {
return err
}

if sb.DataAreaSize == 0 || uint64(sb.DataAreaOffset)+uint64(sb.DataAreaSize) > r.regionSize ||
sb.HeadOffset > sb.DataAreaSize || sb.TailOffset > sb.DataAreaSize ||
sb.HeadOffset%storage.SectorSize != 0 || sb.TailOffset%storage.SectorSize != 0 {
return fmt.Errorf("%w: data area %d+%d, head %d, tail %d in %d-byte region",
ErrJournalCorrupt, sb.DataAreaOffset, sb.DataAreaSize, sb.HeadOffset, sb.TailOffset, r.regionSize)
}

r.superblock = sb
return nil
}
Expand Down
2 changes: 1 addition & 1 deletion internal/journal/region_test.go
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@ import (

// createTestDevice creates a temporary file for testing.
// The file is sparse and suitable for O_DIRECT operations.
func createTestDevice(t *testing.T, size int64) (*storage.Device, func()) {
func createTestDevice(t testing.TB, size int64) (*storage.Device, func()) {
t.Helper()

// Create temp file
Expand Down

Large diffs are not rendered by default.

2 changes: 2 additions & 0 deletions internal/journal/testdata/fuzz/FuzzTxnRecord/540d1d5219eb7445
Original file line number Diff line number Diff line change
@@ -0,0 +1,2 @@
go test fuzz v1
[]byte("TXNR\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\b\x01\x00\x00\x05\x00\x00\x008(\xceH\xc6x\xe1\x18\xf0\"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\x00\x00\x00X\x1b\xfd\x13\x00\x00\x00\x00\x00\x02\x00\x00$\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00d\x00\x00\x00\x00\x00\x00\x00\x01\x01\x00\x00\x00\x00\x00\x00a\x00\x00\x00\x00\x01\x00\x000\x7f\x00\x00")
3 changes: 3 additions & 0 deletions internal/journal/transaction.go
Original file line number Diff line number Diff line change
Expand Up @@ -309,6 +309,9 @@ func IterateEntries(buf []byte, fn func(entry *TxnEntry, payload []byte) error)
return err
}

if entry.Length < TxnEntryHeaderSize {
return ErrCorruptTxn
}
if offset+int(entry.Length) > len(buf) {
return ErrTxnTooSmall
}
Expand Down
Loading
Loading