summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--cmd/btrfs-dump-tree/main.go4
-rw-r--r--cmd/btrfs-fsck/pass1.go4
-rw-r--r--cmd/btrfs-fsck/pass2.go8
-rw-r--r--cmd/btrfs-ls-trees/main.go4
-rw-r--r--pkg/btrfs/btree.go48
-rw-r--r--pkg/btrfs/io2_fs.go4
-rw-r--r--pkg/btrfsmisc/print_tree.go8
-rw-r--r--pkg/btrfsmisc/walk.go20
8 files changed, 50 insertions, 50 deletions
diff --git a/cmd/btrfs-dump-tree/main.go b/cmd/btrfs-dump-tree/main.go
index b226af3..c7e4beb 100644
--- a/cmd/btrfs-dump-tree/main.go
+++ b/cmd/btrfs-dump-tree/main.go
@@ -63,8 +63,8 @@ func Main(imgfilename string) (err error) {
return err
}
}
- if err := fs.WalkTree(superblock.Data.RootTree, btrfs.WalkTreeHandler{
- Item: func(_ btrfs.WalkTreePath, item btrfs.Item) error {
+ if err := fs.TreeWalk(superblock.Data.RootTree, btrfs.TreeWalkHandler{
+ Item: func(_ btrfs.TreeWalkPath, item btrfs.Item) error {
if item.Head.Key.ItemType != btrfsitem.ROOT_ITEM_KEY {
return nil
}
diff --git a/cmd/btrfs-fsck/pass1.go b/cmd/btrfs-fsck/pass1.go
index 5188d65..36bc1ae 100644
--- a/cmd/btrfs-fsck/pass1.go
+++ b/cmd/btrfs-fsck/pass1.go
@@ -23,8 +23,8 @@ func pass1(fs *btrfs.FS, superblock *util.Ref[btrfs.PhysicalAddr, btrfs.Superblo
fmt.Printf("Pass 1: ... walking fs\n")
visitedNodes := make(map[btrfs.LogicalAddr]struct{})
btrfsmisc.WalkFS(fs, btrfsmisc.WalkFSHandler{
- WalkTreeHandler: btrfs.WalkTreeHandler{
- Node: func(path btrfs.WalkTreePath, node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
+ TreeWalkHandler: btrfs.TreeWalkHandler{
+ Node: func(path btrfs.TreeWalkPath, node *util.Ref[btrfs.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)
diff --git a/cmd/btrfs-fsck/pass2.go b/cmd/btrfs-fsck/pass2.go
index 7970cca..bcc57a5 100644
--- a/cmd/btrfs-fsck/pass2.go
+++ b/cmd/btrfs-fsck/pass2.go
@@ -14,8 +14,8 @@ func pass2(fs *btrfs.FS, foundNodes map[btrfs.LogicalAddr]struct{}) {
visitedNodes := make(map[btrfs.LogicalAddr]struct{})
btrfsmisc.WalkFS(fs, btrfsmisc.WalkFSHandler{
- WalkTreeHandler: btrfs.WalkTreeHandler{
- Node: func(path btrfs.WalkTreePath, node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
+ TreeWalkHandler: btrfs.TreeWalkHandler{
+ Node: func(path btrfs.TreeWalkPath, node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
visitedNodes[node.Addr] = struct{}{}
return nil
},
@@ -37,8 +37,8 @@ func pass2(fs *btrfs.FS, foundNodes map[btrfs.LogicalAddr]struct{}) {
orphanedRoots[node] = struct{}{}
}
for potentialRoot := range orphanedRoots {
- if err := fs.WalkTree(potentialRoot, btrfs.WalkTreeHandler{
- Node: func(path btrfs.WalkTreePath, _ *util.Ref[btrfs.LogicalAddr, btrfs.Node], _ error) error {
+ if err := fs.TreeWalk(potentialRoot, btrfs.TreeWalkHandler{
+ Node: func(path btrfs.TreeWalkPath, _ *util.Ref[btrfs.LogicalAddr, btrfs.Node], _ error) error {
nodeAddr := path[len(path)-1].NodeAddr
if nodeAddr != potentialRoot {
delete(orphanedRoots, nodeAddr)
diff --git a/cmd/btrfs-ls-trees/main.go b/cmd/btrfs-ls-trees/main.go
index c3156f5..96638ed 100644
--- a/cmd/btrfs-ls-trees/main.go
+++ b/cmd/btrfs-ls-trees/main.go
@@ -45,8 +45,8 @@ func Main(imgfilenames ...string) (err error) {
Err: func(_ error) {
treeErrCnt++
},
- WalkTreeHandler: btrfs.WalkTreeHandler{
- Item: func(_ btrfs.WalkTreePath, item btrfs.Item) error {
+ TreeWalkHandler: btrfs.TreeWalkHandler{
+ Item: func(_ btrfs.TreeWalkPath, item btrfs.Item) error {
typ := item.Head.Key.ItemType
treeItemCnt[typ] = treeItemCnt[typ] + 1
return nil
diff --git a/pkg/btrfs/btree.go b/pkg/btrfs/btree.go
index d2ba2dd..99c909f 100644
--- a/pkg/btrfs/btree.go
+++ b/pkg/btrfs/btree.go
@@ -11,8 +11,8 @@ import (
"lukeshu.com/btrfs-tools/pkg/util"
)
-// A WalkTreePathElem essentially represents a KeyPointer.
-type WalkTreePathElem struct {
+// A TreeWalkPathElem essentially represents a KeyPointer.
+type TreeWalkPathElem struct {
// ItemIdx is the index of this KeyPointer in the parent Node;
// or -1 if this is the root and there is no KeyPointer.
ItemIdx int
@@ -25,7 +25,7 @@ type WalkTreePathElem struct {
NodeLevel uint8
}
-func (elem WalkTreePathElem) writeNodeTo(w io.Writer) {
+func (elem TreeWalkPathElem) writeNodeTo(w io.Writer) {
if elem.NodeLevel != math.MaxUint8 {
fmt.Fprintf(w, "node:%d@%v", elem.NodeLevel, elem.NodeAddr)
} else {
@@ -37,9 +37,9 @@ func (elem WalkTreePathElem) writeNodeTo(w io.Writer) {
//
// - For .Item() callbacks, the last element will always have a
// NodeAddr of 0.
-type WalkTreePath []WalkTreePathElem
+type TreeWalkPath []TreeWalkPathElem
-func (path WalkTreePath) String() string {
+func (path TreeWalkPath) String() string {
if len(path) == 0 {
return "(empty-path)"
}
@@ -55,16 +55,16 @@ func (path WalkTreePath) String() string {
return ret.String()
}
-type WalkTreeHandler struct {
+type TreeWalkHandler struct {
// Callbacks for entire nodes
- PreNode func(WalkTreePath) error
- Node func(WalkTreePath, *util.Ref[LogicalAddr, Node], error) error
- PostNode func(WalkTreePath, *util.Ref[LogicalAddr, Node]) error
+ PreNode func(TreeWalkPath) error
+ Node func(TreeWalkPath, *util.Ref[LogicalAddr, Node], error) error
+ PostNode func(TreeWalkPath, *util.Ref[LogicalAddr, Node]) error
// Callbacks for items on internal nodes
- PreKeyPointer func(WalkTreePath, KeyPointer) error
- PostKeyPointer func(WalkTreePath, KeyPointer) error
+ PreKeyPointer func(TreeWalkPath, KeyPointer) error
+ PostKeyPointer func(TreeWalkPath, KeyPointer) error
// Callbacks for items on leaf nodes
- Item func(WalkTreePath, Item) error
+ Item func(TreeWalkPath, Item) error
}
// The lifecycle of callbacks is:
@@ -80,18 +80,18 @@ type WalkTreeHandler struct {
// else:
// 004 .Item()
// 007 .PostNode()
-func (fs *FS) WalkTree(nodeAddr LogicalAddr, cbs WalkTreeHandler) error {
- path := WalkTreePath{
- WalkTreePathElem{
+func (fs *FS) TreeWalk(treeRoot LogicalAddr, cbs TreeWalkHandler) error {
+ path := TreeWalkPath{
+ TreeWalkPathElem{
ItemIdx: -1,
- NodeAddr: nodeAddr,
+ NodeAddr: treeRoot,
NodeLevel: math.MaxUint8,
},
}
- return fs.walkTree(path, cbs)
+ return fs.treeWalk(path, cbs)
}
-func (fs *FS) walkTree(path WalkTreePath, cbs WalkTreeHandler) error {
+func (fs *FS) treeWalk(path TreeWalkPath, cbs TreeWalkHandler) error {
if path[len(path)-1].NodeAddr == 0 {
return nil
}
@@ -107,7 +107,7 @@ func (fs *FS) walkTree(path WalkTreePath, cbs WalkTreeHandler) error {
node, err := fs.ReadNode(path[len(path)-1].NodeAddr)
if node != nil {
if exp := path[len(path)-1].NodeLevel; exp != math.MaxUint8 && node.Data.Head.Level != exp && err == nil {
- err = fmt.Errorf("btrfs.FS.WalkTree: node@%v: expected level %v but has level %v",
+ err = fmt.Errorf("btrfs.FS.TreeWalk: node@%v: expected level %v but has level %v",
node.Addr, exp, node.Data.Head.Level)
}
path[len(path)-1].NodeLevel = node.Data.Head.Level
@@ -119,11 +119,11 @@ func (fs *FS) walkTree(path WalkTreePath, cbs WalkTreeHandler) error {
if errors.Is(err, iofs.SkipDir) {
return nil
}
- return fmt.Errorf("btrfs.FS.WalkTree: %w", err)
+ return fmt.Errorf("btrfs.FS.TreeWalk: %w", err)
}
if node != nil {
for i, item := range node.Data.BodyInternal {
- itemPath := append(path, WalkTreePathElem{
+ itemPath := append(path, TreeWalkPathElem{
ItemIdx: i,
NodeAddr: item.BlockPtr,
NodeLevel: node.Data.Head.Level - 1,
@@ -136,7 +136,7 @@ func (fs *FS) walkTree(path WalkTreePath, cbs WalkTreeHandler) error {
return err
}
}
- if err := fs.walkTree(itemPath, cbs); err != nil {
+ if err := fs.treeWalk(itemPath, cbs); err != nil {
return err
}
if cbs.PostKeyPointer != nil {
@@ -150,14 +150,14 @@ func (fs *FS) walkTree(path WalkTreePath, cbs WalkTreeHandler) error {
}
for i, item := range node.Data.BodyLeaf {
if cbs.Item != nil {
- itemPath := append(path, WalkTreePathElem{
+ itemPath := append(path, TreeWalkPathElem{
ItemIdx: i,
})
if err := cbs.Item(itemPath, item); err != nil {
if errors.Is(err, iofs.SkipDir) {
continue
}
- return fmt.Errorf("btrfs.FS.WalkTree: callback: %w", err)
+ return fmt.Errorf("btrfs.FS.TreeWalk: callback: %w", err)
}
}
}
diff --git a/pkg/btrfs/io2_fs.go b/pkg/btrfs/io2_fs.go
index 740e6e6..d71d4b2 100644
--- a/pkg/btrfs/io2_fs.go
+++ b/pkg/btrfs/io2_fs.go
@@ -150,8 +150,8 @@ func (fs *FS) initDev(sb *util.Ref[PhysicalAddr, Superblock]) error {
}
}
}
- if err := fs.WalkTree(sb.Data.ChunkTree, WalkTreeHandler{
- Item: func(_ WalkTreePath, item Item) error {
+ if err := fs.TreeWalk(sb.Data.ChunkTree, TreeWalkHandler{
+ Item: func(_ TreeWalkPath, item Item) error {
if item.Head.Key.ItemType != btrfsitem.CHUNK_ITEM_KEY {
return nil
}
diff --git a/pkg/btrfsmisc/print_tree.go b/pkg/btrfsmisc/print_tree.go
index c11a294..3f1dd46 100644
--- a/pkg/btrfsmisc/print_tree.go
+++ b/pkg/btrfsmisc/print_tree.go
@@ -14,8 +14,8 @@ import (
// kernel-shared/print-tree.c:btrfs_print_tree() and
// kernel-shared/print-tree.c:btrfs_print_leaf()
func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error {
- return fs.WalkTree(root, btrfs.WalkTreeHandler{
- Node: func(path btrfs.WalkTreePath, nodeRef *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
+ return fs.TreeWalk(root, btrfs.TreeWalkHandler{
+ Node: func(path btrfs.TreeWalkPath, nodeRef *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
if err != nil {
fmt.Fprintf(os.Stderr, "error: %v: %v\n", path, err)
}
@@ -24,14 +24,14 @@ func PrintTree(fs *btrfs.FS, root btrfs.LogicalAddr) error {
}
return nil
},
- PreKeyPointer: func(_ btrfs.WalkTreePath, item btrfs.KeyPointer) error {
+ PreKeyPointer: func(_ btrfs.TreeWalkPath, item btrfs.KeyPointer) error {
fmt.Printf("\t%v block %v gen %v\n",
FmtKey(item.Key),
item.BlockPtr,
item.Generation)
return nil
},
- Item: func(path btrfs.WalkTreePath, item btrfs.Item) error {
+ Item: func(path btrfs.TreeWalkPath, item btrfs.Item) error {
i := path[len(path)-1].ItemIdx
fmt.Printf("\titem %v %v itemoff %v itemsize %v\n",
i,
diff --git a/pkg/btrfsmisc/walk.go b/pkg/btrfsmisc/walk.go
index a82bd5f..545afb9 100644
--- a/pkg/btrfsmisc/walk.go
+++ b/pkg/btrfsmisc/walk.go
@@ -10,7 +10,7 @@ import (
type WalkErr struct {
TreeName string
- Path btrfs.WalkTreePath
+ Path btrfs.TreeWalkPath
Err error
}
@@ -29,7 +29,7 @@ type WalkFSHandler struct {
PreTree func(name string, laddr btrfs.LogicalAddr)
PostTree func(name string, laddr btrfs.LogicalAddr)
// Callbacks for nodes or smaller
- btrfs.WalkTreeHandler
+ btrfs.TreeWalkHandler
}
// WalkFS walks all trees in a *btrfs.FS. Rather than returning an
@@ -37,7 +37,7 @@ type WalkFSHandler struct {
// will always be of type WalkErr.
func WalkFS(fs *btrfs.FS, cbs WalkFSHandler) {
var treeName string
- handleErr := func(path btrfs.WalkTreePath, err error) {
+ handleErr := func(path btrfs.TreeWalkPath, err error) {
cbs.Err(WalkErr{
TreeName: treeName,
Path: path,
@@ -50,7 +50,7 @@ func WalkFS(fs *btrfs.FS, cbs WalkFSHandler) {
Root btrfs.LogicalAddr
}
origItem := cbs.Item
- cbs.Item = func(path btrfs.WalkTreePath, item btrfs.Item) error {
+ cbs.Item = func(path btrfs.TreeWalkPath, item btrfs.Item) error {
if item.Head.Key.ItemType == btrfsitem.ROOT_ITEM_KEY {
root, ok := item.Body.(btrfsitem.Root)
if !ok {
@@ -73,7 +73,7 @@ func WalkFS(fs *btrfs.FS, cbs WalkFSHandler) {
}
origNode := cbs.Node
- cbs.Node = func(path btrfs.WalkTreePath, node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
+ cbs.Node = func(path btrfs.TreeWalkPath, node *util.Ref[btrfs.LogicalAddr, btrfs.Node], err error) error {
if err != nil {
handleErr(path, err)
}
@@ -92,28 +92,28 @@ func WalkFS(fs *btrfs.FS, cbs WalkFSHandler) {
treeName = "root tree"
cbs.PreTree(treeName, superblock.Data.RootTree)
- if err := fs.WalkTree(superblock.Data.RootTree, cbs.WalkTreeHandler); err != nil {
+ if err := fs.TreeWalk(superblock.Data.RootTree, cbs.TreeWalkHandler); err != nil {
handleErr(nil, err)
}
cbs.PostTree(treeName, superblock.Data.RootTree)
treeName = "chunk tree"
cbs.PreTree(treeName, superblock.Data.ChunkTree)
- if err := fs.WalkTree(superblock.Data.ChunkTree, cbs.WalkTreeHandler); err != nil {
+ if err := fs.TreeWalk(superblock.Data.ChunkTree, cbs.TreeWalkHandler); err != nil {
handleErr(nil, err)
}
cbs.PostTree(treeName, superblock.Data.ChunkTree)
treeName = "log tree"
cbs.PreTree(treeName, superblock.Data.LogTree)
- if err := fs.WalkTree(superblock.Data.LogTree, cbs.WalkTreeHandler); err != nil {
+ if err := fs.TreeWalk(superblock.Data.LogTree, cbs.TreeWalkHandler); err != nil {
handleErr(nil, err)
}
cbs.PostTree(treeName, superblock.Data.LogTree)
treeName = "block group tree"
cbs.PreTree(treeName, superblock.Data.BlockGroupRoot)
- if err := fs.WalkTree(superblock.Data.BlockGroupRoot, cbs.WalkTreeHandler); err != nil {
+ if err := fs.TreeWalk(superblock.Data.BlockGroupRoot, cbs.TreeWalkHandler); err != nil {
handleErr(nil, err)
}
cbs.PostTree(treeName, superblock.Data.BlockGroupRoot)
@@ -121,7 +121,7 @@ func WalkFS(fs *btrfs.FS, cbs WalkFSHandler) {
for _, tree := range foundTrees {
treeName = tree.Name
cbs.PreTree(treeName, tree.Root)
- if err := fs.WalkTree(tree.Root, cbs.WalkTreeHandler); err != nil {
+ if err := fs.TreeWalk(tree.Root, cbs.TreeWalkHandler); err != nil {
handleErr(nil, err)
}
cbs.PostTree(treeName, tree.Root)
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-11-10 10:54:17 +0000