tree-wide: Have "interior" rather than "internal" be the antonym of "leaf"

Because "internal" has a meaning in the Go world, and it's confusing.

5 files changed, 49 insertions, 49 deletions

diff --git a/cmd/btrfs-rec/inspect/dumptrees/print_tree.go b/cmd/btrfs-rec/inspect/dumptrees/print_tree.go
index 676306a..b7e7552 100644
--- a/cmd/btrfs-rec/inspect/dumptrees/print_tree.go
+++ b/cmd/btrfs-rec/inspect/dumptrees/print_tree.go
@@ -375,7 +375,7 @@ func printTree(ctx context.Context, out io.Writer, fs *btrfs.FS, treeID btrfspri
 // printHeaderInfo mimics btrfs-progs kernel-shared/print-tree.c:print_header_info()
 func printHeaderInfo(out io.Writer, node btrfstree.Node) {
 	var typename string
-	if node.Head.Level > 0 { // internal node
+	if node.Head.Level > 0 { // interior node
 		typename = "node"
 		textui.Fprintf(out, "node %v level %v items %v free space %v",
 			node.Head.Addr,
diff --git a/lib/btrfs/btrfstree/btree_tree.go b/lib/btrfs/btrfstree/btree_tree.go
index a39a795..f88dd44 100644
--- a/lib/btrfs/btrfstree/btree_tree.go
+++ b/lib/btrfs/btrfstree/btree_tree.go
@@ -37,7 +37,7 @@ type TreeOperator interface {
 	//     002 (read node)
 	//     003 .Node() (or .BadNode())
 	//         for item in node.items:
-	//           if internal:
+	//           if interior:
 	//     004     .PreKeyPointer()
 	//     005     (recurse)
 	//     006     .PostKeyPointer()
@@ -68,7 +68,7 @@ type TreeWalkHandler struct {
 	Node     func(TreePath, *diskio.Ref[btrfsvol.LogicalAddr, Node]) error
 	BadNode  func(TreePath, *diskio.Ref[btrfsvol.LogicalAddr, Node], error) error
 	PostNode func(TreePath, *diskio.Ref[btrfsvol.LogicalAddr, Node]) error
-	// Callbacks for items on internal nodes
+	// Callbacks for items on interior nodes
 	PreKeyPointer  func(TreePath, KeyPointer) error
 	PostKeyPointer func(TreePath, KeyPointer) error
 	// Callbacks for items on leaf nodes
@@ -169,10 +169,10 @@ func (fs TreeOperatorImpl) treeWalk(ctx context.Context, path TreePath, errHandl
 		return
 	}
 	if node != nil {
-		for i, item := range node.Data.BodyInternal {
+		for i, item := range node.Data.BodyInterior {
 			toMaxKey := path.Node(-1).ToMaxKey
-			if i+1 < len(node.Data.BodyInternal) {
-				toMaxKey = node.Data.BodyInternal[i+1].Key.Mm()
+			if i+1 < len(node.Data.BodyInterior) {
+				toMaxKey = node.Data.BodyInterior[i+1].Key.Mm()
 			}
 			itemPath := append(path, TreePathElem{
 				FromTree:         node.Data.Head.Owner,
@@ -261,9 +261,9 @@ func (fs TreeOperatorImpl) treeSearch(treeRoot TreeRoot, fn func(btrfsprim.Key,
 		}
 
 		if node.Data.Head.Level > 0 {
-			// internal node
+			// interior node
 
-			// Search for the right-most node.Data.BodyInternal item for which
+			// Search for the right-most node.Data.BodyInterior item for which
 			// `fn(item.Key) >= 0`.
 			//
 			//    + + + + 0 - - - -
@@ -271,7 +271,7 @@ func (fs TreeOperatorImpl) treeSearch(treeRoot TreeRoot, fn func(btrfsprim.Key,
 			// There may or may not be a value that returns '0'.
 			//
 			// i.e. find the highest value that isn't too high.
-			lastGood, ok := slices.SearchHighest(node.Data.BodyInternal, func(kp KeyPointer) int {
+			lastGood, ok := slices.SearchHighest(node.Data.BodyInterior, func(kp KeyPointer) int {
 				return slices.Min(fn(kp.Key, math.MaxUint32), 0) // don't return >0; a key can't be "too low"
 			})
 			if !ok {
@@ -279,16 +279,16 @@ func (fs TreeOperatorImpl) treeSearch(treeRoot TreeRoot, fn func(btrfsprim.Key,
 				return nil, nil, iofs.ErrNotExist
 			}
 			toMaxKey := path.Node(-1).ToMaxKey
-			if lastGood+1 < len(node.Data.BodyInternal) {
-				toMaxKey = node.Data.BodyInternal[lastGood+1].Key.Mm()
+			if lastGood+1 < len(node.Data.BodyInterior) {
+				toMaxKey = node.Data.BodyInterior[lastGood+1].Key.Mm()
 			}
 			path = append(path, TreePathElem{
 				FromTree:         node.Data.Head.Owner,
 				FromItemIdx:      lastGood,
-				ToNodeAddr:       node.Data.BodyInternal[lastGood].BlockPtr,
-				ToNodeGeneration: node.Data.BodyInternal[lastGood].Generation,
+				ToNodeAddr:       node.Data.BodyInterior[lastGood].BlockPtr,
+				ToNodeGeneration: node.Data.BodyInterior[lastGood].Generation,
 				ToNodeLevel:      node.Data.Head.Level - 1,
-				ToKey:            node.Data.BodyInternal[lastGood].Key,
+				ToKey:            node.Data.BodyInterior[lastGood].Key,
 				ToMaxKey:         toMaxKey,
 			})
 			FreeNodeRef(node)
@@ -344,7 +344,7 @@ func (fs TreeOperatorImpl) prev(path TreePath, node *diskio.Ref[btrfsvol.Logical
 				FreeNodeRef(node)
 				return nil, nil, err
 			}
-			path.Node(-1).ToNodeAddr = node.Data.BodyInternal[path.Node(-1).FromItemIdx].BlockPtr
+			path.Node(-1).ToNodeAddr = node.Data.BodyInterior[path.Node(-1).FromItemIdx].BlockPtr
 		}
 	}
 	// go down
@@ -360,11 +360,11 @@ func (fs TreeOperatorImpl) prev(path TreePath, node *diskio.Ref[btrfsvol.Logical
 		if node.Data.Head.Level > 0 {
 			path = append(path, TreePathElem{
 				FromTree:         node.Data.Head.Owner,
-				FromItemIdx:      len(node.Data.BodyInternal) - 1,
-				ToNodeAddr:       node.Data.BodyInternal[len(node.Data.BodyInternal)-1].BlockPtr,
-				ToNodeGeneration: node.Data.BodyInternal[len(node.Data.BodyInternal)-1].Generation,
+				FromItemIdx:      len(node.Data.BodyInterior) - 1,
+				ToNodeAddr:       node.Data.BodyInterior[len(node.Data.BodyInterior)-1].BlockPtr,
+				ToNodeGeneration: node.Data.BodyInterior[len(node.Data.BodyInterior)-1].Generation,
 				ToNodeLevel:      node.Data.Head.Level - 1,
-				ToKey:            node.Data.BodyInternal[len(node.Data.BodyInternal)-1].Key,
+				ToKey:            node.Data.BodyInterior[len(node.Data.BodyInterior)-1].Key,
 				ToMaxKey:         path.Node(-1).ToMaxKey,
 			})
 		} else {
@@ -427,7 +427,7 @@ func (fs TreeOperatorImpl) next(path TreePath, node *diskio.Ref[btrfsvol.Logical
 				FreeNodeRef(node)
 				return nil, nil, err
 			}
-			path.Node(-1).ToNodeAddr = node.Data.BodyInternal[path.Node(-1).FromItemIdx].BlockPtr
+			path.Node(-1).ToNodeAddr = node.Data.BodyInterior[path.Node(-1).FromItemIdx].BlockPtr
 		}
 	}
 	// go down
@@ -443,24 +443,24 @@ func (fs TreeOperatorImpl) next(path TreePath, node *diskio.Ref[btrfsvol.Logical
 		}
 		if node.Data.Head.Level > 0 {
 			toMaxKey := path.Node(-1).ToMaxKey
-			if len(node.Data.BodyInternal) > 1 {
-				toMaxKey = node.Data.BodyInternal[1].Key.Mm()
+			if len(node.Data.BodyInterior) > 1 {
+				toMaxKey = node.Data.BodyInterior[1].Key.Mm()
 			}
 			path = append(path, TreePathElem{
 				FromTree:         node.Data.Head.Owner,
 				FromItemIdx:      0,
-				ToNodeAddr:       node.Data.BodyInternal[0].BlockPtr,
-				ToNodeGeneration: node.Data.BodyInternal[0].Generation,
+				ToNodeAddr:       node.Data.BodyInterior[0].BlockPtr,
+				ToNodeGeneration: node.Data.BodyInterior[0].Generation,
 				ToNodeLevel:      node.Data.Head.Level - 1,
-				ToKey:            node.Data.BodyInternal[0].Key,
+				ToKey:            node.Data.BodyInterior[0].Key,
 				ToMaxKey:         toMaxKey,
 			})
 		} else {
 			path = append(path, TreePathElem{
 				FromTree:    node.Data.Head.Owner,
 				FromItemIdx: 0,
-				ToKey:       node.Data.BodyInternal[0].Key,
-				ToMaxKey:    node.Data.BodyInternal[0].Key,
+				ToKey:       node.Data.BodyInterior[0].Key,
+				ToMaxKey:    node.Data.BodyInterior[0].Key,
 			})
 		}
 	}
diff --git a/lib/btrfs/btrfstree/types_node.go b/lib/btrfs/btrfstree/types_node.go
index 675cf66..150539d 100644
--- a/lib/btrfs/btrfstree/types_node.go
+++ b/lib/btrfs/btrfstree/types_node.go
@@ -89,7 +89,7 @@ type Node struct {
 
 	// The node's body (which one of these is present depends on
 	// the node's type, as specified in the header)
-	BodyInternal []KeyPointer // for internal nodes
+	BodyInterior []KeyPointer // for interior nodes
 	BodyLeaf     []Item       // for leave nodes
 
 	Padding []byte
@@ -105,7 +105,7 @@ type NodeHeader struct {
 	Generation    btrfsprim.Generation `bin:"off=0x50, siz=0x8"`
 	Owner         btrfsprim.ObjID      `bin:"off=0x58, siz=0x8"` // The ID of the tree that contains this node
 	NumItems      uint32               `bin:"off=0x60, siz=0x4"` // [ignored-when-writing]
-	Level         uint8                `bin:"off=0x64, siz=0x1"` // 0 for leaf nodes, >=1 for internal nodes
+	Level         uint8                `bin:"off=0x64, siz=0x1"` // 0 for leaf nodes, >=1 for interior nodes
 	binstruct.End `bin:"off=0x65"`
 }
 
@@ -122,10 +122,10 @@ func (node Node) MaxItems() uint32 {
 
 func (node Node) MinItem() (btrfsprim.Key, bool) {
 	if node.Head.Level > 0 {
-		if len(node.BodyInternal) == 0 {
+		if len(node.BodyInterior) == 0 {
 			return btrfsprim.Key{}, false
 		}
-		return node.BodyInternal[0].Key, true
+		return node.BodyInterior[0].Key, true
 	} else {
 		if len(node.BodyLeaf) == 0 {
 			return btrfsprim.Key{}, false
@@ -136,10 +136,10 @@ func (node Node) MinItem() (btrfsprim.Key, bool) {
 
 func (node Node) MaxItem() (btrfsprim.Key, bool) {
 	if node.Head.Level > 0 {
-		if len(node.BodyInternal) == 0 {
+		if len(node.BodyInterior) == 0 {
 			return btrfsprim.Key{}, false
 		}
-		return node.BodyInternal[len(node.BodyInternal)-1].Key, true
+		return node.BodyInterior[len(node.BodyInterior)-1].Key, true
 	} else {
 		if len(node.BodyLeaf) == 0 {
 			return btrfsprim.Key{}, false
@@ -186,7 +186,7 @@ func (node *Node) UnmarshalBinary(nodeBuf []byte) (int, error) {
 			n, nodeHeaderSize)
 	}
 	if node.Head.Level > 0 {
-		_n, err := node.unmarshalInternal(nodeBuf[n:])
+		_n, err := node.unmarshalInterior(nodeBuf[n:])
 		n += _n
 		if err != nil {
 			return n, fmt.Errorf("btrfsprim: %w", err)
@@ -214,7 +214,7 @@ func (node Node) MarshalBinary() ([]byte, error) {
 			nodeHeaderSize, node.Size)
 	}
 	if node.Head.Level > 0 {
-		node.Head.NumItems = uint32(len(node.BodyInternal))
+		node.Head.NumItems = uint32(len(node.BodyInterior))
 	} else {
 		node.Head.NumItems = uint32(len(node.BodyLeaf))
 	}
@@ -232,7 +232,7 @@ func (node Node) MarshalBinary() ([]byte, error) {
 	}
 
 	if node.Head.Level > 0 {
-		if err := node.marshalInternalTo(buf[nodeHeaderSize:]); err != nil {
+		if err := node.marshalInteriorTo(buf[nodeHeaderSize:]); err != nil {
 			return buf, err
 		}
 	} else {
@@ -244,7 +244,7 @@ func (node Node) MarshalBinary() ([]byte, error) {
 	return buf, nil
 }
 
-// Node: "internal" ////////////////////////////////////////////////////////////////////////////////
+// Node: "interior" ////////////////////////////////////////////////////////////////////////////////
 
 type KeyPointer struct {
 	Key           btrfsprim.Key        `bin:"off=0x0, siz=0x11"`
@@ -253,11 +253,11 @@ type KeyPointer struct {
 	binstruct.End `bin:"off=0x21"`
 }
 
-func (node *Node) unmarshalInternal(bodyBuf []byte) (int, error) {
+func (node *Node) unmarshalInterior(bodyBuf []byte) (int, error) {
 	n := 0
-	node.BodyInternal = make([]KeyPointer, node.Head.NumItems)
-	for i := range node.BodyInternal {
-		_n, err := binstruct.Unmarshal(bodyBuf[n:], &node.BodyInternal[i])
+	node.BodyInterior = make([]KeyPointer, node.Head.NumItems)
+	for i := range node.BodyInterior {
+		_n, err := binstruct.Unmarshal(bodyBuf[n:], &node.BodyInterior[i])
 		n += _n
 		if err != nil {
 			return n, fmt.Errorf("item %v: %w", i, err)
@@ -267,9 +267,9 @@ func (node *Node) unmarshalInternal(bodyBuf []byte) (int, error) {
 	return len(bodyBuf), nil
 }
 
-func (node *Node) marshalInternalTo(bodyBuf []byte) error {
+func (node *Node) marshalInteriorTo(bodyBuf []byte) error {
 	n := 0
-	for i, item := range node.BodyInternal {
+	for i, item := range node.BodyInterior {
 		bs, err := binstruct.Marshal(item)
 		if err != nil {
 			return fmt.Errorf("item %v: %w", i, err)
diff --git a/lib/btrfsutil/graph.go b/lib/btrfsutil/graph.go
index 9e453eb..09a17b4 100644
--- a/lib/btrfsutil/graph.go
+++ b/lib/btrfsutil/graph.go
@@ -183,8 +183,8 @@ func (g Graph) InsertNode(nodeRef *diskio.Ref[btrfsvol.LogicalAddr, btrfstree.No
 		}
 	} else {
 		g.Nodes[nodeRef.Addr] = nodeData
-		kps := make([]GraphEdge, len(nodeRef.Data.BodyInternal))
-		for i, kp := range nodeRef.Data.BodyInternal {
+		kps := make([]GraphEdge, len(nodeRef.Data.BodyInterior))
+		for i, kp := range nodeRef.Data.BodyInterior {
 			kps[i] = GraphEdge{
 				FromNode:     nodeRef.Addr,
 				FromItem:     i,
diff --git a/lib/btrfsutil/skinny_paths.go b/lib/btrfsutil/skinny_paths.go
index 1695990..da86273 100644
--- a/lib/btrfsutil/skinny_paths.go
+++ b/lib/btrfsutil/skinny_paths.go
@@ -60,13 +60,13 @@ func (a *SkinnyPathArena) getItem(parent btrfstree.TreePath, itemIdx int) (btrfs
 		return btrfstree.TreePathElem{}, err
 	}
 	if node.Data.Head.Level > 0 {
-		if itemIdx >= len(node.Data.BodyInternal) {
+		if itemIdx >= len(node.Data.BodyInterior) {
 			panic("should not happen")
 		}
-		for i, item := range node.Data.BodyInternal {
+		for i, item := range node.Data.BodyInterior {
 			toMaxKey := parent.Node(-1).ToMaxKey
-			if i+1 < len(node.Data.BodyInternal) {
-				toMaxKey = node.Data.BodyInternal[i+1].Key.Mm()
+			if i+1 < len(node.Data.BodyInterior) {
+				toMaxKey = node.Data.BodyInterior[i+1].Key.Mm()
 			}
 			elem := btrfstree.TreePathElem{
 				FromTree:         node.Data.Head.Owner,