Don't let TreeWalk bail early, add TreeID in to TreePath

11 files changed, 501 insertions, 525 deletions

diff --git a/cmd/btrfs-fsck/pass1.go b/cmd/btrfs-fsck/pass1.go
index 0899cfc..c75e066 100644
--- a/cmd/btrfs-fsck/pass1.go
+++ b/cmd/btrfs-fsck/pass1.go
@@ -24,18 +24,12 @@ func pass1(ctx context.Context, fs *btrfs.FS, superblock *util.Ref[btrfsvol.Phys
 	visitedNodes := make(map[btrfsvol.LogicalAddr]struct{})
 	btrfsutil.WalkAllTrees(fs, btrfsutil.WalkAllTreesHandler{
 		TreeWalkHandler: btrfs.TreeWalkHandler{
-			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
-				if err != nil {
-					err = fmt.Errorf("%v: %w", path, err)
-					fmt.Printf("Pass 1: ... walk fs: error: %v\n", err)
-				}
-				if node != nil {
-					visitedNodes[node.Addr] = struct{}{}
-				}
-				return err
+			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node]) error {
+				visitedNodes[node.Addr] = struct{}{}
+				return nil
 			},
 		},
-		Err: func(err error) {
+		Err: func(err *btrfsutil.WalkError) {
 			fmt.Printf("Pass 1: ... walk fs: error: %v\n", err)
 		},
 	})
diff --git a/cmd/btrfs-fsck/pass2.go b/cmd/btrfs-fsck/pass2.go
index 9256220..78bd2e5 100644
--- a/cmd/btrfs-fsck/pass2.go
+++ b/cmd/btrfs-fsck/pass2.go
@@ -19,12 +19,12 @@ func pass2(fs *btrfs.FS, foundNodes map[btrfsvol.LogicalAddr]struct{}) {
 	visitedNodes := make(map[btrfsvol.LogicalAddr]struct{})
 	btrfsutil.WalkAllTrees(fs, btrfsutil.WalkAllTreesHandler{
 		TreeWalkHandler: btrfs.TreeWalkHandler{
-			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
+			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node]) error {
 				visitedNodes[node.Addr] = struct{}{}
 				return nil
 			},
 		},
-		Err: func(err error) {
+		Err: func(err *btrfsutil.WalkError) {
 			fmt.Printf("Pass 2: walk FS: error: %v\n", err)
 		},
 	})
diff --git a/cmd/btrfs-rec/inspect_dumptrees.go b/cmd/btrfs-rec/inspect_dumptrees.go
index 5ddff60..4abeaba 100644
--- a/cmd/btrfs-rec/inspect_dumptrees.go
+++ b/cmd/btrfs-rec/inspect_dumptrees.go
@@ -22,10 +22,11 @@ func init() {
 			Short: "A clone of `btrfs inspect-internal dump-tree`",
 			Args:  cliutil.WrapPositionalArgs(cobra.NoArgs),
 		},
-		RunE: func(fs *btrfs.FS, _ *cobra.Command, _ []string) error {
+		RunE: func(fs *btrfs.FS, cmd *cobra.Command, _ []string) error {
 			const version = "5.18.1"
 			fmt.Printf("btrfs-progs v%v\n", version)
-			return btrfsinspect.DumpTrees(os.Stdout, os.Stderr, fs)
+			btrfsinspect.DumpTrees(cmd.Context(), os.Stdout, fs)
+			return nil
 		},
 	})
 }
diff --git a/cmd/btrfs-rec/inspect_lstrees.go b/cmd/btrfs-rec/inspect_lstrees.go
index 976514f..e308b20 100644
--- a/cmd/btrfs-rec/inspect_lstrees.go
+++ b/cmd/btrfs-rec/inspect_lstrees.go
@@ -35,7 +35,7 @@ func init() {
 					treeItemCnt = make(map[btrfsitem.Type]int)
 					fmt.Printf("tree id=%v name=%q\n", treeID, name)
 				},
-				Err: func(_ error) {
+				Err: func(_ *btrfsutil.WalkError) {
 					treeErrCnt++
 				},
 				TreeWalkHandler: btrfs.TreeWalkHandler{
diff --git a/cmd/btrfs-rec/repair_clearbadnodes.go b/cmd/btrfs-rec/repair_clearbadnodes.go
index 58b8bd6..3ae0810 100644
--- a/cmd/btrfs-rec/repair_clearbadnodes.go
+++ b/cmd/btrfs-rec/repair_clearbadnodes.go
@@ -5,8 +5,6 @@
 package main
 
 import (
-	"os"
-
 	"github.com/datawire/ocibuild/pkg/cliutil"
 	"github.com/spf13/cobra"
 
@@ -21,8 +19,8 @@ func init() {
 			Short: "Overwrite corrupt nodes with empty nodes",
 			Args:  cliutil.WrapPositionalArgs(cobra.NoArgs),
 		},
-		RunE: func(fs *btrfs.FS, _ *cobra.Command, _ []string) error {
-			return btrfsrepair.ClearBadNodes(os.Stdout, os.Stderr, fs)
+		RunE: func(fs *btrfs.FS, cmd *cobra.Command, _ []string) error {
+			return btrfsrepair.ClearBadNodes(cmd.Context(), fs)
 		},
 	})
 }
diff --git a/lib/btrfs/io2_lv.go b/lib/btrfs/io2_lv.go
index dce6e27..aac902b 100644
--- a/lib/btrfs/io2_lv.go
+++ b/lib/btrfs/io2_lv.go
@@ -5,10 +5,12 @@
 package btrfs
 
 import (
+	"context"
 	"fmt"
 	"io"
 
 	"github.com/datawire/dlib/derror"
+	"github.com/datawire/dlib/dlog"
 
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsitem"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
@@ -26,7 +28,7 @@ type FS struct {
 
 var _ util.File[btrfsvol.LogicalAddr] = (*FS)(nil)
 
-func (fs *FS) AddDevice(dev *Device) error {
+func (fs *FS) AddDevice(ctx context.Context, dev *Device) error {
 	sb, err := dev.Superblock()
 	if err != nil {
 		return err
@@ -37,7 +39,7 @@ func (fs *FS) AddDevice(dev *Device) error {
 	fs.cacheSuperblocks = nil
 	fs.cacheSuperblock = nil
 	if err := fs.initDev(sb); err != nil {
-		return err
+		dlog.Errorf(ctx, "error: AddDevice: %q: %v", dev.Name(), err)
 	}
 	return nil
 }
@@ -157,20 +159,27 @@ func (fs *FS) initDev(sb *util.Ref[btrfsvol.PhysicalAddr, Superblock]) error {
 			}
 		}
 	}
-	if err := fs.TreeWalk(CHUNK_TREE_OBJECTID, TreeWalkHandler{
-		Item: func(_ TreePath, item Item) error {
-			if item.Head.Key.ItemType != btrfsitem.CHUNK_ITEM_KEY {
-				return nil
-			}
-			for _, mapping := range item.Body.(btrfsitem.Chunk).Mappings(item.Head.Key) {
-				if err := fs.LV.AddMapping(mapping); err != nil {
-					return err
+	var errs derror.MultiError
+	fs.TreeWalk(CHUNK_TREE_OBJECTID,
+		func(err *TreeError) {
+			errs = append(errs, err)
+		},
+		TreeWalkHandler{
+			Item: func(_ TreePath, item Item) error {
+				if item.Head.Key.ItemType != btrfsitem.CHUNK_ITEM_KEY {
+					return nil
 				}
-			}
-			return nil
+				for _, mapping := range item.Body.(btrfsitem.Chunk).Mappings(item.Head.Key) {
+					if err := fs.LV.AddMapping(mapping); err != nil {
+						return err
+					}
+				}
+				return nil
+			},
 		},
-	}); err != nil {
-		return err
+	)
+	if len(errs) > 0 {
+		return errs
 	}
 	return nil
 }
diff --git a/lib/btrfs/io3_btree.go b/lib/btrfs/io3_btree.go
index 7e0f8af..14419fe 100644
--- a/lib/btrfs/io3_btree.go
+++ b/lib/btrfs/io3_btree.go
@@ -5,7 +5,6 @@
 package btrfs
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	iofs "io/fs"
@@ -66,7 +65,10 @@ import (
 // the path would be
 //
 //     {-1, 0x01, 3}→{8, 0x02, 2}→{7, 0x03, 1}→{4, 0x04, 0}→{2, 0, 0}
-type TreePath []TreePathElem
+type TreePath struct {
+	TreeID ObjID
+	Nodes  []TreePathElem
+}
 
 // A TreePathElem essentially represents a KeyPointer.
 type TreePathElem struct {
@@ -87,21 +89,46 @@ func (elem TreePathElem) writeNodeTo(w io.Writer) {
 }
 
 func (path TreePath) String() string {
-	if len(path) == 0 {
-		return "(empty-path)"
-	}
 	var ret strings.Builder
-	path[0].writeNodeTo(&ret)
-	for _, elem := range path[1:] {
-		fmt.Fprintf(&ret, "[%v]", elem.ItemIdx)
-		if elem.NodeAddr != 0 {
-			ret.WriteString("->")
-			elem.writeNodeTo(&ret)
+	fmt.Fprintf(&ret, "%s->", path.TreeID.Format(btrfsitem.ROOT_ITEM_KEY))
+	if len(path.Nodes) == 0 {
+		ret.WriteString("(empty-path)")
+	} else {
+		path.Nodes[0].writeNodeTo(&ret)
+		for _, elem := range path.Nodes[1:] {
+			fmt.Fprintf(&ret, "[%v]", elem.ItemIdx)
+			if elem.NodeAddr != 0 {
+				ret.WriteString("->")
+				elem.writeNodeTo(&ret)
+			}
 		}
 	}
 	return ret.String()
 }
 
+func (path TreePath) DeepCopy() TreePath {
+	return TreePath{
+		TreeID: path.TreeID,
+		Nodes:  append([]TreePathElem(nil), path.Nodes...),
+	}
+}
+
+func (path TreePath) Append(elem TreePathElem) TreePath {
+	path.Nodes = append(path.Nodes, elem)
+	return path
+}
+
+type TreeError struct {
+	Path TreePath
+	Err  error
+}
+
+func (e *TreeError) Unwrap() error { return e.Err }
+
+func (e *TreeError) Error() string {
+	return fmt.Sprintf("%v: %v", e.Path, e.Err)
+}
+
 // A treeRoot is more-or-less a btrfsitem.Root, but simpler and generalized for
 type treeRoot struct {
 	TreeID     ObjID
@@ -174,7 +201,8 @@ func (fs *FS) lookupTree(treeID ObjID) (*treeRoot, error) {
 type TreeWalkHandler struct {
 	// Callbacks for entire nodes
 	PreNode  func(TreePath) error
-	Node     func(TreePath, *util.Ref[btrfsvol.LogicalAddr, Node], error) error
+	Node     func(TreePath, *util.Ref[btrfsvol.LogicalAddr, Node]) error
+	BadNode  func(TreePath, *util.Ref[btrfsvol.LogicalAddr, Node], error) error
 	PostNode func(TreePath, *util.Ref[btrfsvol.LogicalAddr, Node]) error
 	// Callbacks for items on internal nodes
 	PreKeyPointer  func(TreePath, KeyPointer) error
@@ -187,7 +215,7 @@ type TreeWalkHandler struct {
 //
 //     001 .PreNode()
 //     002 (read node)
-//     003 .Node()
+//     003 .Node() (or .BadNode())
 //         for item in node.items:
 //           if internal:
 //     004     .PreKeyPointer()
@@ -196,116 +224,101 @@ type TreeWalkHandler struct {
 //           else:
 //     004     .Item()
 //     007 .PostNode()
-func (fs *FS) TreeWalk(treeID ObjID, cbs TreeWalkHandler) error {
-	rootInfo, err := fs.lookupTree(treeID)
-	if err != nil {
-		return err
-	}
+func (fs *FS) TreeWalk(treeID ObjID, errHandle func(*TreeError), cbs TreeWalkHandler) {
 	path := TreePath{
-		TreePathElem{
-			ItemIdx:   -1,
-			NodeAddr:  rootInfo.RootNode,
-			NodeLevel: rootInfo.Level,
-		},
+		TreeID: treeID,
 	}
-	return fs.treeWalk(path, cbs)
+	rootInfo, err := fs.lookupTree(treeID)
+	if err != nil {
+		errHandle(&TreeError{Path: path, Err: err})
+		return
+	}
+	path = path.Append(TreePathElem{
+		ItemIdx:   -1,
+		NodeAddr:  rootInfo.RootNode,
+		NodeLevel: rootInfo.Level,
+	})
+	fs.treeWalk(path, errHandle, cbs)
 }
 
-func (fs *FS) treeWalk(path TreePath, cbs TreeWalkHandler) error {
-	if path[len(path)-1].NodeAddr == 0 {
-		return nil
+func (fs *FS) treeWalk(path TreePath, errHandle func(*TreeError), cbs TreeWalkHandler) {
+	if path.Nodes[len(path.Nodes)-1].NodeAddr == 0 {
+		return
 	}
 
 	if cbs.PreNode != nil {
 		if err := cbs.PreNode(path); err != nil {
-			if errors.Is(err, iofs.SkipDir) {
-				return nil
-			}
-			return err
+			errHandle(&TreeError{Path: path, Err: err})
 		}
 	}
-	node, err := fs.readNodeAtLevel(path[len(path)-1].NodeAddr, path[len(path)-1].NodeLevel)
-	if node != nil && err == nil {
-		path[len(path)-1].NodeLevel = node.Data.Head.Level
-	}
-	if cbs.Node != nil {
-		err = cbs.Node(path, node, err)
+	node, err := fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-1].NodeAddr, path.Nodes[len(path.Nodes)-1].NodeLevel)
+	if err != nil && node != nil && cbs.BadNode != nil {
+		// opportunity to fix the node
+		err = cbs.BadNode(path, node, err)
 	}
 	if err != nil {
-		if errors.Is(err, iofs.SkipDir) {
-			return nil
+		errHandle(&TreeError{Path: path, Err: err})
+	} else {
+		if err := cbs.Node(path, node); err != nil {
+			errHandle(&TreeError{Path: path, Err: err})
 		}
-		return fmt.Errorf("btrfs.FS.TreeWalk: %w", err)
 	}
 	if node != nil {
 		for i, item := range node.Data.BodyInternal {
-			itemPath := append(path, TreePathElem{
+			itemPath := path.Append(TreePathElem{
 				ItemIdx:   i,
 				NodeAddr:  item.BlockPtr,
 				NodeLevel: node.Data.Head.Level - 1,
 			})
 			if cbs.PreKeyPointer != nil {
 				if err := cbs.PreKeyPointer(itemPath, item); err != nil {
-					if errors.Is(err, iofs.SkipDir) {
-						continue
-					}
-					return err
+					errHandle(&TreeError{Path: path, Err: err})
 				}
 			}
-			if err := fs.treeWalk(itemPath, cbs); err != nil {
-				return err
-			}
+			fs.treeWalk(itemPath, errHandle, cbs)
 			if cbs.PostKeyPointer != nil {
 				if err := cbs.PostKeyPointer(itemPath, item); err != nil {
-					if errors.Is(err, iofs.SkipDir) {
-						continue
-					}
-					return err
+					errHandle(&TreeError{Path: path, Err: err})
 				}
 			}
 		}
 		for i, item := range node.Data.BodyLeaf {
 			if cbs.Item != nil {
-				itemPath := append(path, TreePathElem{
+				itemPath := path.Append(TreePathElem{
 					ItemIdx: i,
 				})
 				if err := cbs.Item(itemPath, item); err != nil {
-					if errors.Is(err, iofs.SkipDir) {
-						continue
-					}
-					return fmt.Errorf("btrfs.FS.TreeWalk: callback: %w", err)
+					errHandle(&TreeError{Path: path, Err: err})
 				}
 			}
 		}
 	}
 	if cbs.PostNode != nil {
 		if err := cbs.PostNode(path, node); err != nil {
-			if errors.Is(err, iofs.SkipDir) {
-				return nil
-			}
-			return err
+			errHandle(&TreeError{Path: path, Err: err})
 		}
 	}
-	return nil
 }
 
 func (fs *FS) treeSearch(treeRoot treeRoot, fn func(Key) int) (TreePath, *util.Ref[btrfsvol.LogicalAddr, Node], error) {
 	path := TreePath{
-		TreePathElem{
-			ItemIdx:   -1,
-			NodeAddr:  treeRoot.RootNode,
-			NodeLevel: treeRoot.Level,
+		TreeID: treeRoot.TreeID,
+		Nodes: []TreePathElem{
+			{
+				ItemIdx:   -1,
+				NodeAddr:  treeRoot.RootNode,
+				NodeLevel: treeRoot.Level,
+			},
 		},
 	}
 	for {
-		if path[len(path)-1].NodeAddr == 0 {
-			return nil, nil, iofs.ErrNotExist
+		if path.Nodes[len(path.Nodes)-1].NodeAddr == 0 {
+			return TreePath{}, nil, iofs.ErrNotExist
 		}
-		node, err := fs.readNodeAtLevel(path[len(path)-1].NodeAddr, path[len(path)-1].NodeLevel)
+		node, err := fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-1].NodeAddr, path.Nodes[len(path.Nodes)-1].NodeLevel)
 		if err != nil {
-			return nil, nil, err
+			return TreePath{}, nil, err
 		}
-		path[len(path)-1].NodeLevel = node.Data.Head.Level
 
 		if node.Data.Head.Level > 0 {
 			// internal node
@@ -330,9 +343,9 @@ func (fs *FS) treeSearch(treeRoot treeRoot, fn func(Key) int) (TreePath, *util.R
 				}
 			}
 			if lastGood < 0 {
-				return nil, nil, iofs.ErrNotExist
+				return TreePath{}, nil, iofs.ErrNotExist
 			}
-			path = append(path, TreePathElem{
+			path = path.Append(TreePathElem{
 				ItemIdx:   lastGood,
 				NodeAddr:  node.Data.BodyInternal[lastGood].BlockPtr,
 				NodeLevel: node.Data.Head.Level - 1,
@@ -361,64 +374,64 @@ func (fs *FS) treeSearch(treeRoot treeRoot, fn func(Key) int) (TreePath, *util.R
 				case direction > 0:
 					beg = midpoint + 1
 				case direction == 0:
-					path = append(path, TreePathElem{
+					path = path.Append(TreePathElem{
 						ItemIdx: midpoint,
 					})
 					return path, node, nil
 				}
 			}
-			return nil, nil, iofs.ErrNotExist
+			return TreePath{}, nil, iofs.ErrNotExist
 		}
 	}
 }
 
 func (fs *FS) prev(path TreePath, node *util.Ref[btrfsvol.LogicalAddr, Node]) (TreePath, *util.Ref[btrfsvol.LogicalAddr, Node], error) {
 	var err error
-	path = append(TreePath(nil), path...)
+	path = path.DeepCopy()
 
 	// go up
-	for path[len(path)-1].ItemIdx < 1 {
-		path = path[:len(path)-1]
-		if len(path) == 0 {
-			return nil, nil, nil
+	for path.Nodes[len(path.Nodes)-1].ItemIdx < 1 {
+		path.Nodes = path.Nodes[:len(path.Nodes)-1]
+		if len(path.Nodes) == 0 {
+			return TreePath{}, nil, nil
 		}
 	}
 	// go left
-	path[len(path)-1].ItemIdx--
-	if path[len(path)-1].NodeAddr != 0 {
-		if node.Addr != path[len(path)-2].NodeAddr {
-			node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+	path.Nodes[len(path.Nodes)-1].ItemIdx--
+	if path.Nodes[len(path.Nodes)-1].NodeAddr != 0 {
+		if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+			node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 			if err != nil {
-				return nil, nil, err
+				return TreePath{}, nil, err
 			}
-			path[len(path)-1].NodeAddr = node.Data.BodyInternal[path[len(path)-1].ItemIdx].BlockPtr
+			path.Nodes[len(path.Nodes)-1].NodeAddr = node.Data.BodyInternal[path.Nodes[len(path.Nodes)-1].ItemIdx].BlockPtr
 		}
 	}
 	// go down
-	for path[len(path)-1].NodeAddr != 0 {
-		if node.Addr != path[len(path)-1].NodeAddr {
-			node, err = fs.readNodeAtLevel(path[len(path)-1].NodeAddr, path[len(path)-1].NodeLevel)
+	for path.Nodes[len(path.Nodes)-1].NodeAddr != 0 {
+		if node.Addr != path.Nodes[len(path.Nodes)-1].NodeAddr {
+			node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-1].NodeAddr, path.Nodes[len(path.Nodes)-1].NodeLevel)
 			if err != nil {
-				return nil, nil, err
+				return TreePath{}, nil, err
 			}
 		}
 		if node.Data.Head.Level > 0 {
-			path = append(path, TreePathElem{
+			path = path.Append(TreePathElem{
 				ItemIdx:   len(node.Data.BodyInternal) - 1,
 				NodeAddr:  node.Data.BodyInternal[len(node.Data.BodyInternal)-1].BlockPtr,
 				NodeLevel: node.Data.Head.Level - 1,
 			})
 		} else {
-			path = append(path, TreePathElem{
+			path = path.Append(TreePathElem{
 				ItemIdx: len(node.Data.BodyLeaf) - 1,
 			})
 		}
 	}
 	// return
-	if node.Addr != path[len(path)-2].NodeAddr {
-		node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+	if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+		node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 		if err != nil {
-			return nil, nil, err
+			return TreePath{}, nil, err
 		}
 	}
 	return path, node, nil
@@ -426,66 +439,66 @@ func (fs *FS) prev(path TreePath, node *util.Ref[btrfsvol.LogicalAddr, Node]) (T
 
 func (fs *FS) next(path TreePath, node *util.Ref[btrfsvol.LogicalAddr, Node]) (TreePath, *util.Ref[btrfsvol.LogicalAddr, Node], error) {
 	var err error
-	path = append(TreePath(nil), path...)
+	path = path.DeepCopy()
 
 	// go up
-	if node.Addr != path[len(path)-2].NodeAddr {
-		node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+	if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+		node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 		if err != nil {
-			return nil, nil, err
+			return TreePath{}, nil, err
 		}
-		path[len(path)-2].NodeLevel = node.Data.Head.Level
+		path.Nodes[len(path.Nodes)-2].NodeLevel = node.Data.Head.Level
 	}
-	for path[len(path)-1].ItemIdx+1 >= int(node.Data.Head.NumItems) {
-		path = path[:len(path)-1]
-		if len(path) == 1 {
-			return nil, nil, nil
+	for path.Nodes[len(path.Nodes)-1].ItemIdx+1 >= int(node.Data.Head.NumItems) {
+		path.Nodes = path.Nodes[:len(path.Nodes)-1]
+		if len(path.Nodes) == 1 {
+			return TreePath{}, nil, nil
 		}
-		if node.Addr != path[len(path)-2].NodeAddr {
-			node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+		if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+			node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 			if err != nil {
-				return nil, nil, err
+				return TreePath{}, nil, err
 			}
-			path[len(path)-2].NodeLevel = node.Data.Head.Level
+			path.Nodes[len(path.Nodes)-2].NodeLevel = node.Data.Head.Level
 		}
 	}
 	// go left
-	path[len(path)-1].ItemIdx++
-	if path[len(path)-1].NodeAddr != 0 {
-		if node.Addr != path[len(path)-2].NodeAddr {
-			node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+	path.Nodes[len(path.Nodes)-1].ItemIdx++
+	if path.Nodes[len(path.Nodes)-1].NodeAddr != 0 {
+		if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+			node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 			if err != nil {
-				return nil, nil, err
+				return TreePath{}, nil, err
 			}
-			path[len(path)-1].NodeAddr = node.Data.BodyInternal[path[len(path)-1].ItemIdx].BlockPtr
+			path.Nodes[len(path.Nodes)-1].NodeAddr = node.Data.BodyInternal[path.Nodes[len(path.Nodes)-1].ItemIdx].BlockPtr
 		}
 	}
 	// go down
-	for path[len(path)-1].NodeAddr != 0 {
-		if node.Addr != path[len(path)-1].NodeAddr {
-			node, err = fs.readNodeAtLevel(path[len(path)-1].NodeAddr, path[len(path)-1].NodeLevel)
+	for path.Nodes[len(path.Nodes)-1].NodeAddr != 0 {
+		if node.Addr != path.Nodes[len(path.Nodes)-1].NodeAddr {
+			node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-1].NodeAddr, path.Nodes[len(path.Nodes)-1].NodeLevel)
 			if err != nil {
-				return nil, nil, err
+				return TreePath{}, nil, err
 			}
-			path[len(path)-1].NodeLevel = node.Data.Head.Level
+			path.Nodes[len(path.Nodes)-1].NodeLevel = node.Data.Head.Level
 		}
 		if node.Data.Head.Level > 0 {
-			path = append(path, TreePathElem{
+			path = path.Append(TreePathElem{
 				ItemIdx:   0,
 				NodeAddr:  node.Data.BodyInternal[len(node.Data.BodyInternal)-1].BlockPtr,
 				NodeLevel: node.Data.Head.Level - 1,
 			})
 		} else {
-			path = append(path, TreePathElem{
+			path = path.Append(TreePathElem{
 				ItemIdx: 0,
 			})
 		}
 	}
 	// return
-	if node.Addr != path[len(path)-2].NodeAddr {
-		node, err = fs.readNodeAtLevel(path[len(path)-2].NodeAddr, path[len(path)-2].NodeLevel)
+	if node.Addr != path.Nodes[len(path.Nodes)-2].NodeAddr {
+		node, err = fs.readNodeAtLevel(path.Nodes[len(path.Nodes)-2].NodeAddr, path.Nodes[len(path.Nodes)-2].NodeLevel)
 		if err != nil {
-			return nil, nil, err
+			return TreePath{}, nil, err
 		}
 	}
 	return path, node, nil
@@ -500,7 +513,7 @@ func (fs *FS) TreeSearch(treeID ObjID, fn func(Key) int) (Item, error) {
 	if err != nil {
 		return Item{}, err
 	}
-	return node.Data.BodyLeaf[path[len(path)-1].ItemIdx], nil
+	return node.Data.BodyLeaf[path.Nodes[len(path.Nodes)-1].ItemIdx], nil
 }
 
 func (fs *FS) TreeLookup(treeID ObjID, key Key) (Item, error) {
@@ -524,7 +537,7 @@ func (fs *FS) TreeSearchAll(treeID ObjID, fn func(Key) int) ([]Item, error) {
 	if err != nil {
 		return nil, err
 	}
-	middleItem := middleNode.Data.BodyLeaf[middlePath[len(middlePath)-1].ItemIdx]
+	middleItem := middleNode.Data.BodyLeaf[middlePath.Nodes[len(middlePath.Nodes)-1].ItemIdx]
 
 	var ret = []Item{middleItem}
 	var errs derror.MultiError
@@ -534,10 +547,10 @@ func (fs *FS) TreeSearchAll(treeID ObjID, fn func(Key) int) ([]Item, error) {
 			errs = append(errs, err)
 			break
 		}
-		if prevPath == nil {
+		if len(prevPath.Nodes) == 0 {
 			break
 		}
-		prevItem := prevNode.Data.BodyLeaf[prevPath[len(prevPath)-1].ItemIdx]
+		prevItem := prevNode.Data.BodyLeaf[prevPath.Nodes[len(prevPath.Nodes)-1].ItemIdx]
 		if fn(prevItem.Head.Key) != 0 {
 			break
 		}
@@ -550,10 +563,10 @@ func (fs *FS) TreeSearchAll(treeID ObjID, fn func(Key) int) ([]Item, error) {
 			errs = append(errs, err)
 			break
 		}
-		if nextPath == nil {
+		if len(nextPath.Nodes) == 0 {
 			break
 		}
-		nextItem := nextNode.Data.BodyLeaf[nextPath[len(nextPath)-1].ItemIdx]
+		nextItem := nextNode.Data.BodyLeaf[nextPath.Nodes[len(nextPath.Nodes)-1].ItemIdx]
 		if fn(nextItem.Head.Key) != 0 {
 			break
 		}
diff --git a/lib/btrfsprogs/btrfsinspect/print_tree.go b/lib/btrfsprogs/btrfsinspect/print_tree.go
index cc57ae6..2bb6762 100644
--- a/lib/btrfsprogs/btrfsinspect/print_tree.go
+++ b/lib/btrfsprogs/btrfsinspect/print_tree.go
@@ -5,10 +5,13 @@
 package btrfsinspect
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"strings"
 
+	"github.com/datawire/dlib/dlog"
+
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsitem"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfssum"
@@ -16,330 +19,328 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/util"
 )
 
-func DumpTrees(out, errout io.Writer, fs *btrfs.FS) error {
+func DumpTrees(ctx context.Context, out io.Writer, fs *btrfs.FS) {
 	superblock, err := fs.Superblock()
 	if err != nil {
-		return err
+		dlog.Error(ctx, err)
+		return
 	}
 
 	if superblock.Data.RootTree != 0 {
 		fmt.Fprintf(out, "root tree\n")
-		if err := printTree(out, errout, fs, btrfs.ROOT_TREE_OBJECTID); err != nil {
-			return err
-		}
+		printTree(ctx, out, fs, btrfs.ROOT_TREE_OBJECTID)
 	}
 	if superblock.Data.ChunkTree != 0 {
 		fmt.Fprintf(out, "chunk tree\n")
-		if err := printTree(out, errout, fs, btrfs.CHUNK_TREE_OBJECTID); err != nil {
-			return err
-		}
+		printTree(ctx, out, fs, btrfs.CHUNK_TREE_OBJECTID)
 	}
 	if superblock.Data.LogTree != 0 {
 		fmt.Fprintf(out, "log root tree\n")
-		if err := printTree(out, errout, fs, btrfs.TREE_LOG_OBJECTID); err != nil {
-			return err
-		}
+		printTree(ctx, out, fs, btrfs.TREE_LOG_OBJECTID)
 	}
 	if superblock.Data.BlockGroupRoot != 0 {
 		fmt.Fprintf(out, "block group tree\n")
-		if err := printTree(out, errout, fs, btrfs.BLOCK_GROUP_TREE_OBJECTID); err != nil {
-			return err
-		}
+		printTree(ctx, out, fs, btrfs.BLOCK_GROUP_TREE_OBJECTID)
 	}
-	if err := fs.TreeWalk(btrfs.ROOT_TREE_OBJECTID, btrfs.TreeWalkHandler{
-		Item: func(_ btrfs.TreePath, item btrfs.Item) error {
-			if item.Head.Key.ItemType != btrfsitem.ROOT_ITEM_KEY {
+	fs.TreeWalk(
+		btrfs.ROOT_TREE_OBJECTID,
+		func(err *btrfs.TreeError) {
+			dlog.Error(ctx, err)
+		},
+		btrfs.TreeWalkHandler{
+			Item: func(_ btrfs.TreePath, item btrfs.Item) error {
+				if item.Head.Key.ItemType != btrfsitem.ROOT_ITEM_KEY {
+					return nil
+				}
+				treeName, ok := map[btrfs.ObjID]string{
+					btrfs.ROOT_TREE_OBJECTID:        "root",
+					btrfs.EXTENT_TREE_OBJECTID:      "extent",
+					btrfs.CHUNK_TREE_OBJECTID:       "chunk",
+					btrfs.DEV_TREE_OBJECTID:         "device",
+					btrfs.FS_TREE_OBJECTID:          "fs",
+					btrfs.ROOT_TREE_DIR_OBJECTID:    "directory",
+					btrfs.CSUM_TREE_OBJECTID:        "checksum",
+					btrfs.ORPHAN_OBJECTID:           "orphan",
+					btrfs.TREE_LOG_OBJECTID:         "log",
+					btrfs.TREE_LOG_FIXUP_OBJECTID:   "log fixup",
+					btrfs.TREE_RELOC_OBJECTID:       "reloc",
+					btrfs.DATA_RELOC_TREE_OBJECTID:  "data reloc",
+					btrfs.EXTENT_CSUM_OBJECTID:      "extent checksum",
+					btrfs.QUOTA_TREE_OBJECTID:       "quota",
+					btrfs.UUID_TREE_OBJECTID:        "uuid",
+					btrfs.FREE_SPACE_TREE_OBJECTID:  "free space",
+					btrfs.MULTIPLE_OBJECTIDS:        "multiple",
+					btrfs.BLOCK_GROUP_TREE_OBJECTID: "block group",
+				}[item.Head.Key.ObjectID]
+				if !ok {
+					treeName = "file"
+				}
+				fmt.Fprintf(out, "%v tree %v \n", treeName, fmtKey(item.Head.Key))
+				printTree(ctx, out, fs, item.Head.Key.ObjectID)
 				return nil
-			}
-			treeName, ok := map[btrfs.ObjID]string{
-				btrfs.ROOT_TREE_OBJECTID:        "root",
-				btrfs.EXTENT_TREE_OBJECTID:      "extent",
-				btrfs.CHUNK_TREE_OBJECTID:       "chunk",
-				btrfs.DEV_TREE_OBJECTID:         "device",
-				btrfs.FS_TREE_OBJECTID:          "fs",
-				btrfs.ROOT_TREE_DIR_OBJECTID:    "directory",
-				btrfs.CSUM_TREE_OBJECTID:        "checksum",
-				btrfs.ORPHAN_OBJECTID:           "orphan",
-				btrfs.TREE_LOG_OBJECTID:         "log",
-				btrfs.TREE_LOG_FIXUP_OBJECTID:   "log fixup",
-				btrfs.TREE_RELOC_OBJECTID:       "reloc",
-				btrfs.DATA_RELOC_TREE_OBJECTID:  "data reloc",
-				btrfs.EXTENT_CSUM_OBJECTID:      "extent checksum",
-				btrfs.QUOTA_TREE_OBJECTID:       "quota",
-				btrfs.UUID_TREE_OBJECTID:        "uuid",
-				btrfs.FREE_SPACE_TREE_OBJECTID:  "free space",
-				btrfs.MULTIPLE_OBJECTIDS:        "multiple",
-				btrfs.BLOCK_GROUP_TREE_OBJECTID: "block group",
-			}[item.Head.Key.ObjectID]
-			if !ok {
-				treeName = "file"
-			}
-			fmt.Fprintf(out, "%v tree %v \n", treeName, fmtKey(item.Head.Key))
-			return printTree(out, errout, fs, item.Head.Key.ObjectID)
+			},
 		},
-	}); err != nil {
-		return err
-	}
+	)
 	fmt.Fprintf(out, "total bytes %v\n", superblock.Data.TotalBytes)
 	fmt.Fprintf(out, "bytes used %v\n", superblock.Data.BytesUsed)
 	fmt.Fprintf(out, "uuid %v\n", superblock.Data.FSUUID)
-	return nil
 }
 
 // printTree mimics btrfs-progs
 // kernel-shared/print-tree.c:btrfs_print_tree() and
 // kernel-shared/print-tree.c:btrfs_print_leaf()
-func printTree(out, errout io.Writer, fs *btrfs.FS, treeID btrfs.ObjID) error {
-	return fs.TreeWalk(treeID, btrfs.TreeWalkHandler{
-		Node: func(path btrfs.TreePath, nodeRef *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
-			if err != nil {
-				fmt.Fprintf(errout, "error: %v: %v\n", path, err)
-			}
-			if nodeRef != nil {
-				printHeaderInfo(out, nodeRef.Data)
-			}
-			return nil
-		},
-		PreKeyPointer: func(_ btrfs.TreePath, item btrfs.KeyPointer) error {
-			fmt.Fprintf(out, "\t%v block %v gen %v\n",
-				fmtKey(item.Key),
-				item.BlockPtr,
-				item.Generation)
-			return nil
+func printTree(ctx context.Context, out io.Writer, fs *btrfs.FS, treeID btrfs.ObjID) {
+	fs.TreeWalk(
+		treeID,
+		func(err *btrfs.TreeError) {
+			dlog.Error(ctx, err)
 		},
-		Item: func(path btrfs.TreePath, item btrfs.Item) error {
-			i := path[len(path)-1].ItemIdx
-			fmt.Fprintf(out, "\titem %v %v itemoff %v itemsize %v\n",
-				i,
-				fmtKey(item.Head.Key),
-				item.Head.DataOffset,
-				item.Head.DataSize)
-			switch body := item.Body.(type) {
-			case btrfsitem.FreeSpaceHeader:
-				fmt.Fprintf(out, "\t\tlocation %v\n", fmtKey(body.Location))
-				fmt.Fprintf(out, "\t\tcache generation %v entries %v bitmaps %v\n",
-					body.Generation, body.NumEntries, body.NumBitmaps)
-			case btrfsitem.Inode:
-				fmt.Fprintf(out, ""+
-					"\t\tgeneration %v transid %v size %v nbytes %v\n"+
-					"\t\tblock group %v mode %o links %v uid %v gid %v rdev %v\n"+
-					"\t\tsequence %v flags %v\n",
-					body.Generation, body.TransID, body.Size, body.NumBytes,
-					body.BlockGroup, body.Mode, body.NLink, body.UID, body.GID, body.RDev,
-					body.Sequence, body.Flags)
-				fmt.Fprintf(out, "\t\tatime %v\n", fmtTime(body.ATime))
-				fmt.Fprintf(out, "\t\tctime %v\n", fmtTime(body.CTime))
-				fmt.Fprintf(out, "\t\tmtime %v\n", fmtTime(body.MTime))
-				fmt.Fprintf(out, "\t\totime %v\n", fmtTime(body.OTime))
-			case btrfsitem.InodeRef:
-				fmt.Fprintf(out, "\t\tindex %v namelen %v name: %s\n",
-					body.Index, body.NameLen, body.Name)
-			//case btrfsitem.INODE_EXTREF_KEY:
-			//	// TODO
-			case btrfsitem.DirEntry:
-				fmt.Fprintf(out, "\t\tlocation %v type %v\n",
-					fmtKey(body.Location), body.Type)
-				fmt.Fprintf(out, "\t\ttransid %v data_len %v name_len %v\n",
-					body.TransID, body.DataLen, body.NameLen)
-				fmt.Fprintf(out, "\t\tname: %s\n", body.Name)
-				if len(body.Data) > 0 {
-					fmt.Fprintf(out, "\t\tdata %v\n", body.Data)
-				}
-			//case btrfsitem.DIR_LOG_INDEX_KEY, btrfsitem.DIR_LOG_ITEM_KEY:
-			//	// TODO
-			case btrfsitem.Root:
-				fmt.Fprintf(out, "\t\tgeneration %v root_dirid %v bytenr %d byte_limit %v bytes_used %v\n",
-					body.Generation, body.RootDirID, body.ByteNr, body.ByteLimit, body.BytesUsed)
-				fmt.Fprintf(out, "\t\tlast_snapshot %v flags %v refs %v\n",
-					body.LastSnapshot, body.Flags, body.Refs)
-				fmt.Fprintf(out, "\t\tdrop_progress %v drop_level %v\n",
-					fmtKey(body.DropProgress), body.DropLevel)
-				fmt.Fprintf(out, "\t\tlevel %v generation_v2 %v\n",
-					body.Level, body.GenerationV2)
-				if body.Generation == body.GenerationV2 {
-					fmt.Fprintf(out, "\t\tuuid %v\n", body.UUID)
-					fmt.Fprintf(out, "\t\tparent_uuid %v\n", body.ParentUUID)
-					fmt.Fprintf(out, "\t\treceived_uuid %v\n", body.ReceivedUUID)
-					fmt.Fprintf(out, "\t\tctransid %v otransid %v stransid %v rtransid %v\n",
-						body.CTransID, body.OTransID, body.STransID, body.RTransID)
+		btrfs.TreeWalkHandler{
+			Node: func(path btrfs.TreePath, nodeRef *util.Ref[btrfsvol.LogicalAddr, btrfs.Node]) error {
+				printHeaderInfo(out, nodeRef.Data)
+				return nil
+			},
+			PreKeyPointer: func(_ btrfs.TreePath, item btrfs.KeyPointer) error {
+				fmt.Fprintf(out, "\t%v block %v gen %v\n",
+					fmtKey(item.Key),
+					item.BlockPtr,
+					item.Generation)
+				return nil
+			},
+			Item: func(path btrfs.TreePath, item btrfs.Item) error {
+				i := path.Nodes[len(path.Nodes)-1].ItemIdx
+				fmt.Fprintf(out, "\titem %v %v itemoff %v itemsize %v\n",
+					i,
+					fmtKey(item.Head.Key),
+					item.Head.DataOffset,
+					item.Head.DataSize)
+				switch body := item.Body.(type) {
+				case btrfsitem.FreeSpaceHeader:
+					fmt.Fprintf(out, "\t\tlocation %v\n", fmtKey(body.Location))
+					fmt.Fprintf(out, "\t\tcache generation %v entries %v bitmaps %v\n",
+						body.Generation, body.NumEntries, body.NumBitmaps)
+				case btrfsitem.Inode:
+					fmt.Fprintf(out, ""+
+						"\t\tgeneration %v transid %v size %v nbytes %v\n"+
+						"\t\tblock group %v mode %o links %v uid %v gid %v rdev %v\n"+
+						"\t\tsequence %v flags %v\n",
+						body.Generation, body.TransID, body.Size, body.NumBytes,
+						body.BlockGroup, body.Mode, body.NLink, body.UID, body.GID, body.RDev,
+						body.Sequence, body.Flags)
+					fmt.Fprintf(out, "\t\tatime %v\n", fmtTime(body.ATime))
 					fmt.Fprintf(out, "\t\tctime %v\n", fmtTime(body.CTime))
+					fmt.Fprintf(out, "\t\tmtime %v\n", fmtTime(body.MTime))
 					fmt.Fprintf(out, "\t\totime %v\n", fmtTime(body.OTime))
-					fmt.Fprintf(out, "\t\tstime %v\n", fmtTime(body.STime))
-					fmt.Fprintf(out, "\t\trtime %v\n", fmtTime(body.RTime))
-				}
-			case btrfsitem.RootRef:
-				var tag string
-				switch item.Head.Key.ItemType {
-				case btrfsitem.ROOT_REF_KEY:
-					tag = "ref"
-				case btrfsitem.ROOT_BACKREF_KEY:
-					tag = "backref"
-				default:
-					tag = fmt.Sprintf("(error: unhandled RootRef item type: %v)", item.Head.Key.ItemType)
-				}
-				fmt.Fprintf(out, "\t\troot %v key dirid %v sequence %v name %s\n",
-					tag, body.DirID, body.Sequence, body.Name)
-			case btrfsitem.Extent:
-				fmt.Fprintf(out, "\t\trefs %v gen %v flags %v\n",
-					body.Head.Refs, body.Head.Generation, body.Head.Flags)
-				if body.Head.Flags.Has(btrfsitem.EXTENT_FLAG_TREE_BLOCK) {
-					fmt.Fprintf(out, "\t\ttree block %v level %v\n",
-						fmtKey(body.Info.Key), body.Info.Level)
-				}
-				printExtentInlineRefs(out, body.Refs)
-			case btrfsitem.Metadata:
-				fmt.Fprintf(out, "\t\trefs %v gen %v flags %v\n",
-					body.Head.Refs, body.Head.Generation, body.Head.Flags)
-				fmt.Fprintf(out, "\t\ttree block skinny level %v\n", item.Head.Key.Offset)
-				printExtentInlineRefs(out, body.Refs)
-			//case btrfsitem.EXTENT_DATA_REF_KEY:
-			//	// TODO
-			//case btrfsitem.SHARED_DATA_REF_KEY:
-			//	// TODO
-			case btrfsitem.ExtentCSum:
-				sb, _ := fs.Superblock()
-				sectorSize := btrfsvol.AddrDelta(sb.Data.SectorSize)
+				case btrfsitem.InodeRef:
+					fmt.Fprintf(out, "\t\tindex %v namelen %v name: %s\n",
+						body.Index, body.NameLen, body.Name)
+				//case btrfsitem.INODE_EXTREF_KEY:
+				//	// TODO
+				case btrfsitem.DirEntry:
+					fmt.Fprintf(out, "\t\tlocation %v type %v\n",
+						fmtKey(body.Location), body.Type)
+					fmt.Fprintf(out, "\t\ttransid %v data_len %v name_len %v\n",
+						body.TransID, body.DataLen, body.NameLen)
+					fmt.Fprintf(out, "\t\tname: %s\n", body.Name)
+					if len(body.Data) > 0 {
+						fmt.Fprintf(out, "\t\tdata %v\n", body.Data)
+					}
+				//case btrfsitem.DIR_LOG_INDEX_KEY, btrfsitem.DIR_LOG_ITEM_KEY:
+				//	// TODO
+				case btrfsitem.Root:
+					fmt.Fprintf(out, "\t\tgeneration %v root_dirid %v bytenr %d byte_limit %v bytes_used %v\n",
+						body.Generation, body.RootDirID, body.ByteNr, body.ByteLimit, body.BytesUsed)
+					fmt.Fprintf(out, "\t\tlast_snapshot %v flags %v refs %v\n",
+						body.LastSnapshot, body.Flags, body.Refs)
+					fmt.Fprintf(out, "\t\tdrop_progress %v drop_level %v\n",
+						fmtKey(body.DropProgress), body.DropLevel)
+					fmt.Fprintf(out, "\t\tlevel %v generation_v2 %v\n",
+						body.Level, body.GenerationV2)
+					if body.Generation == body.GenerationV2 {
+						fmt.Fprintf(out, "\t\tuuid %v\n", body.UUID)
+						fmt.Fprintf(out, "\t\tparent_uuid %v\n", body.ParentUUID)
+						fmt.Fprintf(out, "\t\treceived_uuid %v\n", body.ReceivedUUID)
+						fmt.Fprintf(out, "\t\tctransid %v otransid %v stransid %v rtransid %v\n",
+							body.CTransID, body.OTransID, body.STransID, body.RTransID)
+						fmt.Fprintf(out, "\t\tctime %v\n", fmtTime(body.CTime))
+						fmt.Fprintf(out, "\t\totime %v\n", fmtTime(body.OTime))
+						fmt.Fprintf(out, "\t\tstime %v\n", fmtTime(body.STime))
+						fmt.Fprintf(out, "\t\trtime %v\n", fmtTime(body.RTime))
+					}
+				case btrfsitem.RootRef:
+					var tag string
+					switch item.Head.Key.ItemType {
+					case btrfsitem.ROOT_REF_KEY:
+						tag = "ref"
+					case btrfsitem.ROOT_BACKREF_KEY:
+						tag = "backref"
+					default:
+						tag = fmt.Sprintf("(error: unhandled RootRef item type: %v)", item.Head.Key.ItemType)
+					}
+					fmt.Fprintf(out, "\t\troot %v key dirid %v sequence %v name %s\n",
+						tag, body.DirID, body.Sequence, body.Name)
+				case btrfsitem.Extent:
+					fmt.Fprintf(out, "\t\trefs %v gen %v flags %v\n",
+						body.Head.Refs, body.Head.Generation, body.Head.Flags)
+					if body.Head.Flags.Has(btrfsitem.EXTENT_FLAG_TREE_BLOCK) {
+						fmt.Fprintf(out, "\t\ttree block %v level %v\n",
+							fmtKey(body.Info.Key), body.Info.Level)
+					}
+					printExtentInlineRefs(out, body.Refs)
+				case btrfsitem.Metadata:
+					fmt.Fprintf(out, "\t\trefs %v gen %v flags %v\n",
+						body.Head.Refs, body.Head.Generation, body.Head.Flags)
+					fmt.Fprintf(out, "\t\ttree block skinny level %v\n", item.Head.Key.Offset)
+					printExtentInlineRefs(out, body.Refs)
+				//case btrfsitem.EXTENT_DATA_REF_KEY:
+				//	// TODO
+				//case btrfsitem.SHARED_DATA_REF_KEY:
+				//	// TODO
+				case btrfsitem.ExtentCSum:
+					sb, _ := fs.Superblock()
+					sectorSize := btrfsvol.AddrDelta(sb.Data.SectorSize)
 
-				start := btrfsvol.LogicalAddr(item.Head.Key.Offset)
-				itemSize := btrfsvol.AddrDelta(len(body.Sums)) * sectorSize
-				fmt.Fprintf(out, "\t\trange start %d end %d length %d",
-					start, start.Add(itemSize), itemSize)
-				sumsPerLine := util.Max(1, len(btrfssum.CSum{})/body.ChecksumSize/2)
+					start := btrfsvol.LogicalAddr(item.Head.Key.Offset)
+					itemSize := btrfsvol.AddrDelta(len(body.Sums)) * sectorSize
+					fmt.Fprintf(out, "\t\trange start %d end %d length %d",
+						start, start.Add(itemSize), itemSize)
+					sumsPerLine := util.Max(1, len(btrfssum.CSum{})/body.ChecksumSize/2)
 
-				pos := start
-				for i, sum := range body.Sums {
-					if i%sumsPerLine == 0 {
-						fmt.Fprintf(out, "\n\t\t")
-					} else {
-						fmt.Fprintf(out, " ")
+					pos := start
+					for i, sum := range body.Sums {
+						if i%sumsPerLine == 0 {
+							fmt.Fprintf(out, "\n\t\t")
+						} else {
+							fmt.Fprintf(out, " ")
+						}
+						fmt.Fprintf(out, "[%d] 0x%s", pos, sum.Fmt(sb.Data.ChecksumType))
+						pos = pos.Add(sectorSize)
 					}
-					fmt.Fprintf(out, "[%d] 0x%s", pos, sum.Fmt(sb.Data.ChecksumType))
-					pos = pos.Add(sectorSize)
-				}
-				fmt.Fprintf(out, "\n")
-			case btrfsitem.FileExtent:
-				fmt.Fprintf(out, "\t\tgeneration %v type %v\n",
-					body.Generation, body.Type)
-				switch body.Type {
-				case btrfsitem.FILE_EXTENT_INLINE:
-					fmt.Fprintf(out, "\t\tinline extent data size %v ram_bytes %v compression %v\n",
-						len(body.BodyInline), body.RAMBytes, body.Compression)
-				case btrfsitem.FILE_EXTENT_PREALLOC:
-					fmt.Fprintf(out, "\t\tprealloc data disk byte %v nr %v\n",
-						body.BodyExtent.DiskByteNr,
-						body.BodyExtent.DiskNumBytes)
-					fmt.Fprintf(out, "\t\tprealloc data offset %v nr %v\n",
-						body.BodyExtent.Offset,
-						body.BodyExtent.NumBytes)
-				case btrfsitem.FILE_EXTENT_REG:
-					fmt.Fprintf(out, "\t\textent data disk byte %d nr %d\n",
-						body.BodyExtent.DiskByteNr,
-						body.BodyExtent.DiskNumBytes)
-					fmt.Fprintf(out, "\t\textent data offset %d nr %d ram %v\n",
-						body.BodyExtent.Offset,
-						body.BodyExtent.NumBytes,
-						body.RAMBytes)
-					fmt.Fprintf(out, "\t\textent compression %v\n",
-						body.Compression)
-				default:
-					fmt.Fprintf(out, "\t\t(error) unknown file extent type %v", body.Type)
-				}
-			case btrfsitem.BlockGroup:
-				fmt.Fprintf(out, "\t\tblock group used %v chunk_objectid %v flags %v\n",
-					body.Used, body.ChunkObjectID, body.Flags)
-			case btrfsitem.FreeSpaceInfo:
-				fmt.Fprintf(out, "\t\tfree space info extent count %v flags %v\n",
-					body.ExtentCount, body.Flags)
-			case btrfsitem.FreeSpaceBitmap:
-				fmt.Fprintf(out, "\t\tfree space bitmap\n")
-			case btrfsitem.Chunk:
-				fmt.Fprintf(out, "\t\tlength %d owner %d stripe_len %v type %v\n",
-					body.Head.Size, body.Head.Owner, body.Head.StripeLen, body.Head.Type)
-				fmt.Fprintf(out, "\t\tio_align %v io_width %v sector_size %v\n",
-					body.Head.IOOptimalAlign, body.Head.IOOptimalWidth, body.Head.IOMinSize)
-				fmt.Fprintf(out, "\t\tnum_stripes %v sub_stripes %v\n",
-					body.Head.NumStripes, body.Head.SubStripes)
-				for i, stripe := range body.Stripes {
-					fmt.Fprintf(out, "\t\t\tstripe %v devid %d offset %d\n",
-						i, stripe.DeviceID, stripe.Offset)
-					fmt.Fprintf(out, "\t\t\tdev_uuid %v\n",
-						stripe.DeviceUUID)
-				}
-			case btrfsitem.Dev:
-				fmt.Fprintf(out, ""+
-					"\t\tdevid %d total_bytes %v bytes_used %v\n"+
-					"\t\tio_align %v io_width %v sector_size %v type %v\n"+
-					"\t\tgeneration %v start_offset %v dev_group %v\n"+
-					"\t\tseek_speed %v bandwidth %v\n"+
-					"\t\tuuid %v\n"+
-					"\t\tfsid %v\n",
-					body.DevID, body.NumBytes, body.NumBytesUsed,
-					body.IOOptimalAlign, body.IOOptimalWidth, body.IOMinSize, body.Type,
-					body.Generation, body.StartOffset, body.DevGroup,
-					body.SeekSpeed, body.Bandwidth,
-					body.DevUUID,
-					body.FSUUID)
-			case btrfsitem.DevExtent:
-				fmt.Fprintf(out, ""+
-					"\t\tdev extent chunk_tree %v\n"+
-					"\t\tchunk_objectid %v chunk_offset %d length %d\n"+
-					"\t\tchunk_tree_uuid %v\n",
-					body.ChunkTree, body.ChunkObjectID, body.ChunkOffset, body.Length,
-					body.ChunkTreeUUID)
-			//case btrfsitem.QGROUP_STATUS_KEY:
-			//	// TODO
-			//case btrfsitem.QGROUP_INFO_KEY:
-			//	// TODO
-			//case btrfsitem.QGROUP_LIMIT_KEY:
-			//	// TODO
-			case btrfsitem.UUIDMap:
-				fmt.Fprintf(out, "\t\tsubvol_id %d\n", body.ObjID)
-			//case btrfsitem.STRING_ITEM_KEY:
-			//	// TODO
-			case btrfsitem.DevStats:
-				fmt.Fprintf(out, "\t\tpersistent item objectid %v offset %v\n",
-					item.Head.Key.ObjectID.Format(item.Head.Key.ItemType), item.Head.Key.Offset)
-				switch item.Head.Key.ObjectID {
-				case btrfs.DEV_STATS_OBJECTID:
-					fmt.Fprintf(out, "\t\tdevice stats\n")
-					fmt.Fprintf(out, "\t\twrite_errs %v read_errs %v flush_errs %v corruption_errs %v generation %v\n",
-						body.Values[btrfsitem.DEV_STAT_WRITE_ERRS],
-						body.Values[btrfsitem.DEV_STAT_READ_ERRS],
-						body.Values[btrfsitem.DEV_STAT_FLUSH_ERRS],
-						body.Values[btrfsitem.DEV_STAT_CORRUPTION_ERRS],
-						body.Values[btrfsitem.DEV_STAT_GENERATION_ERRS])
-				default:
-					fmt.Fprintf(out, "\t\tunknown persistent item objectid %v\n", item.Head.Key.ObjectID)
-				}
-			//case btrfsitem.TEMPORARY_ITEM_KEY:
-			//	// TODO
-			case btrfsitem.Empty:
-				switch item.Head.Key.ItemType {
-				case btrfsitem.ORPHAN_ITEM_KEY: // 48
-					fmt.Fprintf(out, "\t\torphan item\n")
-				case btrfsitem.TREE_BLOCK_REF_KEY: // 176
-					fmt.Fprintf(out, "\t\ttree block backref\n")
-				case btrfsitem.SHARED_BLOCK_REF_KEY: // 182
-					fmt.Fprintf(out, "\t\tshared block backref\n")
-				case btrfsitem.FREE_SPACE_EXTENT_KEY: // 199
-					fmt.Fprintf(out, "\t\tfree space extent\n")
-				case btrfsitem.QGROUP_RELATION_KEY: // 246
-					// do nothing
-				//case btrfsitem.EXTENT_REF_V0_KEY:
-				//	fmt.Fprintf(out, "\t\textent ref v0 (deprecated)\n")
-				//case btrfsitem.CSUM_ITEM_KEY:
-				//	fmt.Fprintf(out, "\t\tcsum item\n")
+					fmt.Fprintf(out, "\n")
+				case btrfsitem.FileExtent:
+					fmt.Fprintf(out, "\t\tgeneration %v type %v\n",
+						body.Generation, body.Type)
+					switch body.Type {
+					case btrfsitem.FILE_EXTENT_INLINE:
+						fmt.Fprintf(out, "\t\tinline extent data size %v ram_bytes %v compression %v\n",
+							len(body.BodyInline), body.RAMBytes, body.Compression)
+					case btrfsitem.FILE_EXTENT_PREALLOC:
+						fmt.Fprintf(out, "\t\tprealloc data disk byte %v nr %v\n",
+							body.BodyExtent.DiskByteNr,
+							body.BodyExtent.DiskNumBytes)
+						fmt.Fprintf(out, "\t\tprealloc data offset %v nr %v\n",
+							body.BodyExtent.Offset,
+							body.BodyExtent.NumBytes)
+					case btrfsitem.FILE_EXTENT_REG:
+						fmt.Fprintf(out, "\t\textent data disk byte %d nr %d\n",
+							body.BodyExtent.DiskByteNr,
+							body.BodyExtent.DiskNumBytes)
+						fmt.Fprintf(out, "\t\textent data offset %d nr %d ram %v\n",
+							body.BodyExtent.Offset,
+							body.BodyExtent.NumBytes,
+							body.RAMBytes)
+						fmt.Fprintf(out, "\t\textent compression %v\n",
+							body.Compression)
+					default:
+						fmt.Fprintf(out, "\t\t(error) unknown file extent type %v", body.Type)
+					}
+				case btrfsitem.BlockGroup:
+					fmt.Fprintf(out, "\t\tblock group used %v chunk_objectid %v flags %v\n",
+						body.Used, body.ChunkObjectID, body.Flags)
+				case btrfsitem.FreeSpaceInfo:
+					fmt.Fprintf(out, "\t\tfree space info extent count %v flags %v\n",
+						body.ExtentCount, body.Flags)
+				case btrfsitem.FreeSpaceBitmap:
+					fmt.Fprintf(out, "\t\tfree space bitmap\n")
+				case btrfsitem.Chunk:
+					fmt.Fprintf(out, "\t\tlength %d owner %d stripe_len %v type %v\n",
+						body.Head.Size, body.Head.Owner, body.Head.StripeLen, body.Head.Type)
+					fmt.Fprintf(out, "\t\tio_align %v io_width %v sector_size %v\n",
+						body.Head.IOOptimalAlign, body.Head.IOOptimalWidth, body.Head.IOMinSize)
+					fmt.Fprintf(out, "\t\tnum_stripes %v sub_stripes %v\n",
+						body.Head.NumStripes, body.Head.SubStripes)
+					for i, stripe := range body.Stripes {
+						fmt.Fprintf(out, "\t\t\tstripe %v devid %d offset %d\n",
+							i, stripe.DeviceID, stripe.Offset)
+						fmt.Fprintf(out, "\t\t\tdev_uuid %v\n",
+							stripe.DeviceUUID)
+					}
+				case btrfsitem.Dev:
+					fmt.Fprintf(out, ""+
+						"\t\tdevid %d total_bytes %v bytes_used %v\n"+
+						"\t\tio_align %v io_width %v sector_size %v type %v\n"+
+						"\t\tgeneration %v start_offset %v dev_group %v\n"+
+						"\t\tseek_speed %v bandwidth %v\n"+
+						"\t\tuuid %v\n"+
+						"\t\tfsid %v\n",
+						body.DevID, body.NumBytes, body.NumBytesUsed,
+						body.IOOptimalAlign, body.IOOptimalWidth, body.IOMinSize, body.Type,
+						body.Generation, body.StartOffset, body.DevGroup,
+						body.SeekSpeed, body.Bandwidth,
+						body.DevUUID,
+						body.FSUUID)
+				case btrfsitem.DevExtent:
+					fmt.Fprintf(out, ""+
+						"\t\tdev extent chunk_tree %v\n"+
+						"\t\tchunk_objectid %v chunk_offset %d length %d\n"+
+						"\t\tchunk_tree_uuid %v\n",
+						body.ChunkTree, body.ChunkObjectID, body.ChunkOffset, body.Length,
+						body.ChunkTreeUUID)
+				//case btrfsitem.QGROUP_STATUS_KEY:
+				//	// TODO
+				//case btrfsitem.QGROUP_INFO_KEY:
+				//	// TODO
+				//case btrfsitem.QGROUP_LIMIT_KEY:
+				//	// TODO
+				case btrfsitem.UUIDMap:
+					fmt.Fprintf(out, "\t\tsubvol_id %d\n", body.ObjID)
+				//case btrfsitem.STRING_ITEM_KEY:
+				//	// TODO
+				case btrfsitem.DevStats:
+					fmt.Fprintf(out, "\t\tpersistent item objectid %v offset %v\n",
+						item.Head.Key.ObjectID.Format(item.Head.Key.ItemType), item.Head.Key.Offset)
+					switch item.Head.Key.ObjectID {
+					case btrfs.DEV_STATS_OBJECTID:
+						fmt.Fprintf(out, "\t\tdevice stats\n")
+						fmt.Fprintf(out, "\t\twrite_errs %v read_errs %v flush_errs %v corruption_errs %v generation %v\n",
+							body.Values[btrfsitem.DEV_STAT_WRITE_ERRS],
+							body.Values[btrfsitem.DEV_STAT_READ_ERRS],
+							body.Values[btrfsitem.DEV_STAT_FLUSH_ERRS],
+							body.Values[btrfsitem.DEV_STAT_CORRUPTION_ERRS],
+							body.Values[btrfsitem.DEV_STAT_GENERATION_ERRS])
+					default:
+						fmt.Fprintf(out, "\t\tunknown persistent item objectid %v\n", item.Head.Key.ObjectID)
+					}
+				//case btrfsitem.TEMPORARY_ITEM_KEY:
+				//	// TODO
+				case btrfsitem.Empty:
+					switch item.Head.Key.ItemType {
+					case btrfsitem.ORPHAN_ITEM_KEY: // 48
+						fmt.Fprintf(out, "\t\torphan item\n")
+					case btrfsitem.TREE_BLOCK_REF_KEY: // 176
+						fmt.Fprintf(out, "\t\ttree block backref\n")
+					case btrfsitem.SHARED_BLOCK_REF_KEY: // 182
+						fmt.Fprintf(out, "\t\tshared block backref\n")
+					case btrfsitem.FREE_SPACE_EXTENT_KEY: // 199
+						fmt.Fprintf(out, "\t\tfree space extent\n")
+					case btrfsitem.QGROUP_RELATION_KEY: // 246
+						// do nothing
+					//case btrfsitem.EXTENT_REF_V0_KEY:
+					//	fmt.Fprintf(out, "\t\textent ref v0 (deprecated)\n")
+					//case btrfsitem.CSUM_ITEM_KEY:
+					//	fmt.Fprintf(out, "\t\tcsum item\n")
+					default:
+						fmt.Fprintf(out, "\t\t(error) unhandled empty item type: %v\n", item.Head.Key.ItemType)
+					}
+				case btrfsitem.Error:
+					fmt.Fprintf(out, "\t\t(error) error item: %v\n", body.Err)
 				default:
-					fmt.Fprintf(out, "\t\t(error) unhandled empty item type: %v\n", item.Head.Key.ItemType)
+					fmt.Fprintf(out, "\t\t(error) unhandled item type: %T\n", body)
 				}
-			case btrfsitem.Error:
-				fmt.Fprintf(out, "\t\t(error) error item: %v\n", body.Err)
-			default:
-				fmt.Fprintf(out, "\t\t(error) unhandled item type: %T\n", body)
-			}
-			return nil
+				return nil
+			},
 		},
-	})
+	)
 }
 
 // printHeaderInfo mimics btrfs-progs kernel-shared/print-tree.c:print_header_info()
diff --git a/lib/btrfsprogs/btrfsrepair/clearnodes.go b/lib/btrfsprogs/btrfsrepair/clearnodes.go
index e9cd879..dbe1c3a 100644
--- a/lib/btrfsprogs/btrfsrepair/clearnodes.go
+++ b/lib/btrfsprogs/btrfsrepair/clearnodes.go
@@ -5,9 +5,11 @@
 package btrfsrepair
 
 import (
+	"context"
 	"errors"
 	"fmt"
-	"io"
+
+	"github.com/datawire/dlib/dlog"
 
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
@@ -15,39 +17,26 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/util"
 )
 
-func ClearBadNodes(out, errout io.Writer, fs *btrfs.FS) error {
+func ClearBadNodes(ctx context.Context, fs *btrfs.FS) error {
 	var uuidsInited bool
 	var metadataUUID, chunkTreeUUID btrfs.UUID
 
-	var treeName string
-	var treeID btrfs.ObjID
 	btrfsutil.WalkAllTrees(fs, btrfsutil.WalkAllTreesHandler{
-		PreTree: func(name string, id btrfs.ObjID) {
-			treeName = name
-			treeID = id
-		},
-		Err: func(err error) {
-			fmt.Fprintf(errout, "error: %v\n", err)
+		Err: func(err *btrfsutil.WalkError) {
+			dlog.Error(ctx, err)
 		},
-		UnsafeNodes: true,
 		TreeWalkHandler: btrfs.TreeWalkHandler{
-			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
-				if err == nil {
-					if !uuidsInited {
-						metadataUUID = node.Data.Head.MetadataUUID
-						chunkTreeUUID = node.Data.Head.ChunkTreeUUID
-						uuidsInited = true
-					}
-					return nil
+			Node: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node]) error {
+				if !uuidsInited {
+					metadataUUID = node.Data.Head.MetadataUUID
+					chunkTreeUUID = node.Data.Head.ChunkTreeUUID
+					uuidsInited = true
 				}
+				return nil
+			},
+			BadNode: func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
 				if !errors.Is(err, btrfs.ErrNotANode) {
-					err = btrfsutil.WalkErr{
-						TreeName: treeName,
-						Path:     path,
-						Err:      err,
-					}
-					fmt.Fprintf(errout, "error: %v\n", err)
-					return nil
+					return err
 				}
 				origErr := err
 				if !uuidsInited {
@@ -66,24 +55,20 @@ func ClearBadNodes(out, errout io.Writer, fs *btrfs.FS) error {
 						BackrefRev:    btrfs.MixedBackrefRev,
 						ChunkTreeUUID: chunkTreeUUID,
 						Generation:    0,
-						Owner:         treeID,
+						Owner:         path.TreeID,
 						NumItems:      0,
-						Level:         path[len(path)-1].NodeLevel,
+						Level:         path.Nodes[len(path.Nodes)-1].NodeLevel,
 					},
 				}
 				node.Data.Head.Checksum, err = node.Data.CalculateChecksum()
 				if err != nil {
-					return btrfsutil.WalkErr{
-						TreeName: treeName,
-						Path:     path,
-						Err:      err,
-					}
+					return err
 				}
 				if err := node.Write(); err != nil {
 					return err
 				}
 
-				fmt.Fprintf(out, "fixed node@%v (err was %v)\n", node.Addr, origErr)
+				dlog.Infof(ctx, "fixed node@%v (err was %v)\n", node.Addr, origErr)
 				return nil
 			},
 		},
diff --git a/lib/btrfsprogs/btrfsutil/open.go b/lib/btrfsprogs/btrfsutil/open.go
index 80bfe7a..c237b54 100644
--- a/lib/btrfsprogs/btrfsutil/open.go
+++ b/lib/btrfsprogs/btrfsutil/open.go
@@ -23,8 +23,8 @@ func Open(ctx context.Context, flag int, filenames ...string) (*btrfs.FS, error)
 			_ = fs.Close()
 			return nil, fmt.Errorf("device file %q: %w", filename, err)
 		}
-		if err := fs.AddDevice(&btrfs.Device{File: fh}); err != nil {
-			dlog.Errorf(ctx, "device file %q: %v", filename, err)
+		if err := fs.AddDevice(ctx, &btrfs.Device{File: fh}); err != nil {
+			return nil, fmt.Errorf("device file %q: %w", filename, err)
 		}
 	}
 	return fs, nil
diff --git a/lib/btrfsprogs/btrfsutil/walk.go b/lib/btrfsprogs/btrfsutil/walk.go
index 0c54384..d2322b2 100644
--- a/lib/btrfsprogs/btrfsutil/walk.go
+++ b/lib/btrfsprogs/btrfsutil/walk.go
@@ -9,47 +9,33 @@ import (
 
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs"
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsitem"
-	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfsvol"
-	"git.lukeshu.com/btrfs-progs-ng/lib/util"
 )
 
-type WalkErr struct {
+type WalkError struct {
 	TreeName string
-	Path     btrfs.TreePath
-	Err      error
+	Err      *btrfs.TreeError
 }
 
-func (e WalkErr) Unwrap() error { return e.Err }
+func (e *WalkError) Unwrap() error { return e.Err }
 
-func (e WalkErr) Error() string {
-	if len(e.Path) == 0 {
-		return fmt.Sprintf("%v: %v", e.TreeName, e.Err)
-	}
-	return fmt.Sprintf("%v: %v: %v", e.TreeName, e.Path, e.Err)
+func (e *WalkError) Error() string {
+	return fmt.Sprintf("%v: %v", e.TreeName, e.Err)
 }
 
 type WalkAllTreesHandler struct {
-	Err func(error)
+	Err func(*WalkError)
 	// Callbacks for entire trees
 	PreTree  func(name string, id btrfs.ObjID)
 	PostTree func(name string, id btrfs.ObjID)
 	// Callbacks for nodes or smaller
-	UnsafeNodes bool
 	btrfs.TreeWalkHandler
 }
 
 // WalkAllTrees walks all trees in a *btrfs.FS.  Rather than returning
 // an error, it calls errCb each time an error is encountered.  The
-// error will always be of type WalkErr.
+// error will always be of type WalkError.
 func WalkAllTrees(fs *btrfs.FS, cbs WalkAllTreesHandler) {
 	var treeName string
-	handleErr := func(path btrfs.TreePath, err error) {
-		cbs.Err(WalkErr{
-			TreeName: treeName,
-			Path:     path,
-			Err:      err,
-		})
-	}
 
 	trees := []struct {
 		Name string
@@ -90,28 +76,17 @@ func WalkAllTrees(fs *btrfs.FS, cbs WalkAllTreesHandler) {
 		return nil
 	}
 
-	if !cbs.UnsafeNodes {
-		origNode := cbs.Node
-		cbs.Node = func(path btrfs.TreePath, node *util.Ref[btrfsvol.LogicalAddr, btrfs.Node], err error) error {
-			if err != nil {
-				handleErr(path, err)
-			}
-			if node != nil && origNode != nil {
-				return origNode(path, node, nil)
-			}
-			return nil
-		}
-	}
-
 	for i := 0; i < len(trees); i++ {
 		tree := trees[i]
 		treeName = tree.Name
 		if cbs.PreTree != nil {
 			cbs.PreTree(treeName, tree.ID)
 		}
-		if err := fs.TreeWalk(tree.ID, cbs.TreeWalkHandler); err != nil {
-			handleErr(nil, err)
-		}
+		fs.TreeWalk(
+			tree.ID,
+			func(err *btrfs.TreeError) { cbs.Err(&WalkError{TreeName: treeName, Err: err}) },
+			cbs.TreeWalkHandler,
+		)
 		if cbs.PostTree != nil {
 			cbs.PostTree(treeName, tree.ID)
 		}