From 5626918663de1d3f606850e25a5b39f940ceb7a2 Mon Sep 17 00:00:00 2001 From: Luke Shumaker Date: Sun, 5 Jun 2022 22:12:51 -0600 Subject: better error handling --- cmd/btrfs-dump-tree/main.go | 2 +- cmd/btrfs-fsck/main.go | 11 +++++-- pkg/btrfs/types_btree.go | 73 ++++++++++++++++++++++----------------------- pkg/btrfsmisc/fsck.go | 34 ++++++++++++--------- pkg/btrfsmisc/print_tree.go | 2 ++ 5 files changed, 67 insertions(+), 55 deletions(-) diff --git a/cmd/btrfs-dump-tree/main.go b/cmd/btrfs-dump-tree/main.go index 12ed269..5df5468 100644 --- a/cmd/btrfs-dump-tree/main.go +++ b/cmd/btrfs-dump-tree/main.go @@ -41,7 +41,7 @@ func Main(imgfilename string) (err error) { } if err := fs.Init(); err != nil { - return err + fmt.Printf("(error) %v\n", err) } superblock, err := fs.Superblock() diff --git a/cmd/btrfs-fsck/main.go b/cmd/btrfs-fsck/main.go index e1a37ab..7823c8d 100644 --- a/cmd/btrfs-fsck/main.go +++ b/cmd/btrfs-fsck/main.go @@ -57,9 +57,14 @@ func Main(imgfilename string) (err error) { fmt.Printf("Pass 1: ... walking chunk tree\n") visitedChunkNodes := make(map[btrfs.LogicalAddr]struct{}) if err := fs.WalkTree(superblock.Data.ChunkTree, btrfs.WalkTreeHandler{ - MidNode: func(node *util.Ref[btrfs.LogicalAddr, btrfs.Node]) error { - visitedChunkNodes[node.Addr] = struct{}{} - return nil + Node: func(node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error { + if err != nil { + fmt.Printf("Pass 1: ... walk chunk tree: error: %v\n", err) + } + if node != nil { + visitedChunkNodes[node.Addr] = struct{}{} + } + return err }, }); err != nil { fmt.Printf("Pass 1: ... walk chunk tree: error: %v\n", err) diff --git a/pkg/btrfs/types_btree.go b/pkg/btrfs/types_btree.go index 89901c3..70737e7 100644 --- a/pkg/btrfs/types_btree.go +++ b/pkg/btrfs/types_btree.go @@ -107,6 +107,9 @@ func (node Node) MaxItems() uint32 { } func (node *Node) UnmarshalBinary(nodeBuf []byte) (int, error) { + node.BodyInternal = nil + node.BodyLeaf = nil + node.Padding = nil n, err := binstruct.Unmarshal(nodeBuf, &node.Head) if err != nil { return n, err @@ -264,52 +267,58 @@ func (fs *FS) ReadNode(addr LogicalAddr) (*util.Ref[LogicalAddr, Node], error) { return nil, err } - var node Node - node.Size = sb.Data.NodeSize + // parse (early) - if _, err := node.UnmarshalBinary(nodeBuf); err != nil { - return nil, fmt.Errorf("btrfs.FS.ReadNode: node@%d: %w", addr, err) + nodeRef := &util.Ref[LogicalAddr, Node]{ + File: fs, + Addr: addr, + Data: Node{ + Size: sb.Data.NodeSize, + }, + } + if _, err := binstruct.Unmarshal(nodeBuf, &nodeRef.Data.Head); err != nil { + return nodeRef, fmt.Errorf("btrfs.FS.ReadNode: node@%d: %w", addr, err) } // sanity checking - if node.Head.MetadataUUID != sb.Data.EffectiveMetadataUUID() { + if nodeRef.Data.Head.MetadataUUID != sb.Data.EffectiveMetadataUUID() { return nil, fmt.Errorf("btrfs.FS.ReadNode: node@%d: does not look like a node", addr) } - if node.Head.Addr != addr { - return nil, fmt.Errorf("btrfs.FS.ReadNode: node@%d: read from laddr=%d but claims to be at laddr=%d", - addr, addr, node.Head.Addr) - } - - stored := node.Head.Checksum + stored := nodeRef.Data.Head.Checksum calced := CRC32c(nodeBuf[binstruct.StaticSize(CSum{}):]) - if calced != stored { - return nil, fmt.Errorf("btrfs.FS.ReadNode: node@%d: checksum mismatch: stored=%s calculated=%s", + if stored != calced { + return nodeRef, fmt.Errorf("btrfs.FS.ReadNode: node@%d: checksum mismatch: stored=%s calculated=%s", addr, stored, calced) } + if nodeRef.Data.Head.Addr != addr { + return nodeRef, fmt.Errorf("btrfs.FS.ReadNode: node@%d: read from laddr=%d but claims to be at laddr=%d", + addr, addr, nodeRef.Data.Head.Addr) + } + + // parse (main) + + if _, err := nodeRef.Data.UnmarshalBinary(nodeBuf); err != nil { + return nodeRef, fmt.Errorf("btrfs.FS.ReadNode: node@%d: %w", addr, err) + } + // return - return &util.Ref[LogicalAddr, Node]{ - File: fs, - Addr: addr, - Data: node, - }, nil + return nodeRef, nil } type WalkTreeHandler struct { // Callbacks for entire nodes PreNode func(LogicalAddr) error - MidNode func(*util.Ref[LogicalAddr, Node]) error + Node func(*util.Ref[LogicalAddr, Node], error) error PostNode func(*util.Ref[LogicalAddr, Node]) error // Callbacks for items on internal nodes PreKeyPointer func(KeyPointer) error PostKeyPointer func(KeyPointer) error // Callbacks for items on leaf nodes Item func(Key, btrfsitem.Item) error - // Error handler - NodeError func(error) error } func (fs *FS) WalkTree(nodeAddr LogicalAddr, cbs WalkTreeHandler) error { @@ -325,24 +334,14 @@ func (fs *FS) WalkTree(nodeAddr LogicalAddr, cbs WalkTreeHandler) error { } } node, err := fs.ReadNode(nodeAddr) - if err != nil { - if cbs.NodeError != nil { - err = cbs.NodeError(err) - } - if err != nil { - if errors.Is(err, iofs.SkipDir) { - return nil - } - return fmt.Errorf("btrfs.FS.WalkTree: %w", err) - } + if cbs.Node != nil { + err = cbs.Node(node, err) } - if cbs.MidNode != nil { - if err := cbs.MidNode(node); err != nil { - if errors.Is(err, iofs.SkipDir) { - return nil - } - return err + if err != nil { + if errors.Is(err, iofs.SkipDir) { + return nil } + return fmt.Errorf("btrfs.FS.WalkTree: %w", err) } for _, item := range node.Data.BodyInternal { if cbs.PreKeyPointer != nil { diff --git a/pkg/btrfsmisc/fsck.go b/pkg/btrfsmisc/fsck.go index 8d20e6e..a771cf4 100644 --- a/pkg/btrfsmisc/fsck.go +++ b/pkg/btrfsmisc/fsck.go @@ -36,26 +36,37 @@ func ScanForNodes(dev *btrfs.Device, sb btrfs.Superblock, fn func(*util.Ref[btrf continue } - // does it look like a node? + // parse (early) + nodeRef := &util.Ref[btrfs.PhysicalAddr, btrfs.Node]{ + File: dev, + Addr: pos, + Data: btrfs.Node{ + Size: sb.NodeSize, + }, + } var nodeHeader btrfs.NodeHeader if _, err := binstruct.Unmarshal(nodeBuf, &nodeHeader); err != nil { fn(nil, fmt.Errorf("sector@%d: %w", pos, err)) } + + // sanity checking + if nodeHeader.MetadataUUID != sb.EffectiveMetadataUUID() { //fmt.Printf("sector@%d does not look like a node\n", pos) continue } - // ok, it looks like a node; go ahead and read it as a node - - nodeRef := &util.Ref[btrfs.PhysicalAddr, btrfs.Node]{ - File: dev, - Addr: pos, - Data: btrfs.Node{ - Size: sb.NodeSize, - }, + stored := nodeRef.Data.Head.Checksum + calced := btrfs.CRC32c(nodeBuf[binstruct.StaticSize(btrfs.CSum{}):]) + if stored != calced { + fn(nodeRef, fmt.Errorf("sector@%d: looks like a node but is corrupt: checksum doesn't match: stored=%s calculated=%s", + pos, stored, calced)) + continue } + + // parse (main) + if _, err := nodeRef.Data.UnmarshalBinary(nodeBuf); err != nil { fn(nil, fmt.Errorf("sector@%d: %w", pos, err)) continue @@ -63,11 +74,6 @@ func ScanForNodes(dev *btrfs.Device, sb btrfs.Superblock, fn func(*util.Ref[btrf // finally, process the node - if nodeRef.Data.Head.Checksum != btrfs.CRC32c(nodeBuf[0x20:]) { - fn(nodeRef, fmt.Errorf("sector@%d looks like a node but is corrupt (checksum doesn't match)", pos)) - continue - } - fn(nodeRef, nil) pos += btrfs.PhysicalAddr(sb.NodeSize) - btrfs.PhysicalAddr(sb.SectorSize) diff --git a/pkg/btrfsmisc/print_tree.go b/pkg/btrfsmisc/print_tree.go index b7c3103..a771b65 100644 --- a/pkg/btrfsmisc/print_tree.go +++ b/pkg/btrfsmisc/print_tree.go @@ -17,6 +17,8 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error { nodeRef, err := fs.ReadNode(root) if err != nil { fmt.Fprintf(os.Stderr, "error: %v\n", err) + } + if nodeRef == nil { return nil } node := nodeRef.Data -- cgit v1.2.3-2-g168b