rename: Move CSumBlockSize from scanforextents to btrfsitem

5 files changed, 31 insertions, 29 deletions

diff --git a/lib/btrfs/btrfsitem/item_extentcsum.go b/lib/btrfs/btrfsitem/item_extentcsum.go
index a945295..b35d333 100644
--- a/lib/btrfs/btrfsitem/item_extentcsum.go
+++ b/lib/btrfs/btrfsitem/item_extentcsum.go
@@ -10,6 +10,8 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfs/btrfssum"
 )
 
+const CSumBlockSize = 4 * 1024
+
 // key.objectid = BTRFS_EXTENT_CSUM_OBJECTID
 // key.offset = laddr of checksummed region
 type ExtentCSum struct { // EXTENT_CSUM=128
diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go b/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
index 0ab933e..0fb4818 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
@@ -25,8 +25,6 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/diskio"
 )
 
-const CSumBlockSize = 4 * 1024
-
 // ShortSum //////////////////////////////////////////////////////////
 
 type ShortSum string
@@ -50,7 +48,7 @@ func (run SumRun[Addr]) NumSums() int {
 }
 
 func (run SumRun[Addr]) Size() btrfsvol.AddrDelta {
-	return btrfsvol.AddrDelta(run.NumSums()) * CSumBlockSize
+	return btrfsvol.AddrDelta(run.NumSums()) * btrfsitem.CSumBlockSize
 }
 
 // Get implements diskio.Sequence[int, ShortSum]
@@ -66,12 +64,12 @@ func (run SumRun[Addr]) SumForAddr(addr Addr) (ShortSum, bool) {
 	if addr < run.Addr || addr >= run.Addr.Add(run.Size()) {
 		return "", false
 	}
-	off := int((addr-run.Addr)/CSumBlockSize) * run.ChecksumSize
+	off := int((addr-run.Addr)/btrfsitem.CSumBlockSize) * run.ChecksumSize
 	return ShortSum(run.Sums[off : off+run.ChecksumSize]), true
 }
 
 func (run SumRun[Addr]) Walk(ctx context.Context, fn func(Addr, ShortSum) error) error {
-	for addr, off := run.Addr, 0; off < len(run.Sums); addr, off = addr+CSumBlockSize, off+run.ChecksumSize {
+	for addr, off := run.Addr, 0; off < len(run.Sums); addr, off = addr+btrfsitem.CSumBlockSize, off+run.ChecksumSize {
 		if err := ctx.Err(); err != nil {
 			return err
 		}
@@ -91,7 +89,7 @@ type SumRunWithGaps[Addr btrfsvol.IntAddr[Addr]] struct {
 }
 
 func (sg SumRunWithGaps[Addr]) NumSums() int {
-	return int(sg.Size / CSumBlockSize)
+	return int(sg.Size / btrfsitem.CSumBlockSize)
 }
 
 func (sg SumRunWithGaps[Addr]) PctFull() float64 {
@@ -114,7 +112,7 @@ func (sg SumRunWithGaps[Addr]) SumForAddr(addr Addr) (ShortSum, error) {
 		if run.Addr.Add(run.Size()) <= addr {
 			continue
 		}
-		off := int((addr-run.Addr)/CSumBlockSize) * run.ChecksumSize
+		off := int((addr-run.Addr)/btrfsitem.CSumBlockSize) * run.ChecksumSize
 		return ShortSum(run.Sums[off : off+run.ChecksumSize]), nil
 	}
 	return "", diskio.ErrWildcard
@@ -122,7 +120,7 @@ func (sg SumRunWithGaps[Addr]) SumForAddr(addr Addr) (ShortSum, error) {
 
 // Get implements diskio.Sequence[int, ShortSum]
 func (sg SumRunWithGaps[Addr]) Get(sumIdx int64) (ShortSum, error) {
-	addr := sg.Addr.Add(btrfsvol.AddrDelta(sumIdx) * CSumBlockSize)
+	addr := sg.Addr.Add(btrfsvol.AddrDelta(sumIdx) * btrfsitem.CSumBlockSize)
 	return sg.SumForAddr(addr)
 }
 
@@ -225,8 +223,8 @@ func SumEverything(ctx context.Context, fs *btrfs.FS) (AllSums, error) {
 					body := item.Body.(btrfsitem.ExtentCSum)
 
 					for i, sum := range body.Sums {
-						laddr := btrfsvol.LogicalAddr(item.Key.Offset) + (btrfsvol.LogicalAddr(i) * CSumBlockSize)
-						if laddr != curAddr+(btrfsvol.LogicalAddr(curSums.Len()/csumSize)*CSumBlockSize) {
+						laddr := btrfsvol.LogicalAddr(item.Key.Offset) + (btrfsvol.LogicalAddr(i) * btrfsitem.CSumBlockSize)
+						if laddr != curAddr+(btrfsvol.LogicalAddr(curSums.Len()/csumSize)*btrfsitem.CSumBlockSize) {
 							if curSums.Len() > 0 {
 								ret.Logical = append(ret.Logical, SumRun[btrfsvol.LogicalAddr]{
 									ChecksumSize: csumSize,
@@ -271,7 +269,7 @@ func SumEverything(ctx context.Context, fs *btrfs.FS) (AllSums, error) {
 			devID, dev := devID, dev
 			grp.Go(dev.Name(), func(ctx context.Context) error {
 				devSize := dev.Size()
-				numSums := int(devSize / CSumBlockSize)
+				numSums := int(devSize / btrfsitem.CSumBlockSize)
 				sums := make([]byte, numSums*csumSize)
 				lastPct := -1
 				progress := func(curSum int) {
@@ -287,7 +285,7 @@ func SumEverything(ctx context.Context, fs *btrfs.FS) (AllSums, error) {
 						return err
 					}
 					progress(i)
-					sum, err := ChecksumPhysical(dev, alg, btrfsvol.PhysicalAddr(i*CSumBlockSize))
+					sum, err := ChecksumPhysical(dev, alg, btrfsvol.PhysicalAddr(i*btrfsitem.CSumBlockSize))
 					if err != nil {
 						return err
 					}
diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/csums_raw.go b/lib/btrfsprogs/btrfsinspect/scanforextents/csums_raw.go
index 83277dd..eae1c4d 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/csums_raw.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/csums_raw.go
@@ -14,7 +14,7 @@ import (
 )
 
 func ChecksumLogical(fs btrfs.Trees, alg btrfssum.CSumType, laddr btrfsvol.LogicalAddr) (btrfssum.CSum, error) {
-	var dat [CSumBlockSize]byte
+	var dat [btrfsitem.CSumBlockSize]byte
 	if _, err := fs.ReadAt(dat[:], laddr); err != nil {
 		return btrfssum.CSum{}, err
 	}
@@ -22,7 +22,7 @@ func ChecksumLogical(fs btrfs.Trees, alg btrfssum.CSumType, laddr btrfsvol.Logic
 }
 
 func ChecksumPhysical(dev *btrfs.Device, alg btrfssum.CSumType, paddr btrfsvol.PhysicalAddr) (btrfssum.CSum, error) {
-	var dat [CSumBlockSize]byte
+	var dat [btrfsitem.CSumBlockSize]byte
 	if _, err := dev.ReadAt(dat[:], paddr); err != nil {
 		return btrfssum.CSum{}, err
 	}
@@ -41,7 +41,7 @@ func LookupCSum(fs btrfs.Trees, alg btrfssum.CSumType, laddr btrfsvol.LogicalAdd
 	item, err := fs.TreeSearch(btrfs.CSUM_TREE_OBJECTID, func(key btrfs.Key, size uint32) int {
 		itemBeg := btrfsvol.LogicalAddr(key.ObjectID)
 		numSums := int64(size) / int64(alg.Size())
-		itemEnd := itemBeg + btrfsvol.LogicalAddr(numSums*CSumBlockSize)
+		itemEnd := itemBeg + btrfsvol.LogicalAddr(numSums*btrfsitem.CSumBlockSize)
 		switch {
 		case itemEnd <= laddr:
 			return 1
@@ -60,7 +60,7 @@ func LookupCSum(fs btrfs.Trees, alg btrfssum.CSumType, laddr btrfsvol.LogicalAdd
 	}
 	ret := make(map[btrfsvol.LogicalAddr]btrfssum.CSum, len(body.Sums))
 	for i, sum := range body.Sums {
-		ret[btrfsvol.LogicalAddr(item.Key.ObjectID)+(btrfsvol.LogicalAddr(i)*CSumBlockSize)] = sum
+		ret[btrfsvol.LogicalAddr(item.Key.ObjectID)+(btrfsvol.LogicalAddr(i)*btrfsitem.CSumBlockSize)] = sum
 	}
 	return ret, nil
 }
diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go b/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
index 1540a2e..be6ee06 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
@@ -11,6 +11,7 @@ import (
 	"golang.org/x/exp/constraints"
 
 	"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/maps"
 )
@@ -62,9 +63,9 @@ func WalkGaps(ctx context.Context,
 			if err := ctx.Err(); err != nil {
 				return err
 			}
-			begAddr := roundUp(gap.Beg, CSumBlockSize)
-			begOff := int(begAddr/CSumBlockSize) * sums.Physical[devID].ChecksumSize
-			endOff := int(gap.End/CSumBlockSize) * sums.Physical[devID].ChecksumSize
+			begAddr := roundUp(gap.Beg, btrfsitem.CSumBlockSize)
+			begOff := int(begAddr/btrfsitem.CSumBlockSize) * sums.Physical[devID].ChecksumSize
+			endOff := int(gap.End/btrfsitem.CSumBlockSize) * sums.Physical[devID].ChecksumSize
 			if err := fn(devID, SumRun[btrfsvol.PhysicalAddr]{
 				ChecksumSize: sums.Physical[devID].ChecksumSize,
 				Addr:         begAddr,
diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go b/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go
index 8ea3113..e980e9c 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go
@@ -11,6 +11,7 @@ import (
 	"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/btrfsvol"
 	"git.lukeshu.com/btrfs-progs-ng/lib/containers"
 	"git.lukeshu.com/btrfs-progs-ng/lib/diskio"
@@ -33,11 +34,11 @@ func ScanForExtents(ctx context.Context, fs *btrfs.FS, blockgroups map[btrfsvol.
 				laddr = next
 				continue
 			}
-			off := int((laddr-run.Addr)/CSumBlockSize) * run.ChecksumSize
+			off := int((laddr-run.Addr)/btrfsitem.CSumBlockSize) * run.ChecksumSize
 			deltaAddr := slices.Min[btrfsvol.AddrDelta](
 				blockgroup.Size-laddr.Sub(blockgroup.LAddr),
-				btrfsvol.AddrDelta((len(run.Sums)-off)/run.ChecksumSize)*CSumBlockSize)
-			deltaOff := int(deltaAddr/CSumBlockSize) * run.ChecksumSize
+				btrfsvol.AddrDelta((len(run.Sums)-off)/run.ChecksumSize)*btrfsitem.CSumBlockSize)
+			deltaOff := int(deltaAddr/btrfsitem.CSumBlockSize) * run.ChecksumSize
 			runs.Runs = append(runs.Runs, SumRun[btrfsvol.LogicalAddr]{
 				ChecksumSize: run.ChecksumSize,
 				Addr:         laddr,
@@ -70,7 +71,7 @@ func ScanForExtents(ctx context.Context, fs *btrfs.FS, blockgroups map[btrfsvol.
 			for _, match := range matches {
 				bgMatches[bgLAddr] = append(bgMatches[bgLAddr], btrfsvol.QualifiedPhysicalAddr{
 					Dev:  devID,
-					Addr: gap.Addr + (btrfsvol.PhysicalAddr(match) * CSumBlockSize),
+					Addr: gap.Addr + (btrfsvol.PhysicalAddr(match) * btrfsitem.CSumBlockSize),
 				})
 			}
 			return nil
@@ -114,7 +115,7 @@ func ScanForExtents(ctx context.Context, fs *btrfs.FS, blockgroups map[btrfsvol.
 	sum2laddrs := make(map[ShortSum][]btrfsvol.LogicalAddr)
 	var numUnmappedBlocks int64
 	if err := sums.WalkLogical(ctx, func(laddr btrfsvol.LogicalAddr, sum ShortSum) error {
-		var dat [CSumBlockSize]byte
+		var dat [btrfsitem.CSumBlockSize]byte
 		if _, err := fs.ReadAt(dat[:], laddr); err != nil {
 			if errors.Is(err, btrfsvol.ErrCouldNotMap) {
 				sum2laddrs[sum] = append(sum2laddrs[sum], laddr)
@@ -187,12 +188,12 @@ type ExtentMappings struct {
 }
 
 func (em *ExtentMappings) considerMapping(ctx context.Context, laddr btrfsvol.LogicalAddr, paddr btrfsvol.QualifiedPhysicalAddr) (btrfsvol.Mapping, bool) {
-	blockgroup := LookupBlockGroup(em.InBlockGroups, laddr, CSumBlockSize)
+	blockgroup := LookupBlockGroup(em.InBlockGroups, laddr, btrfsitem.CSumBlockSize)
 	if blockgroup == nil {
 		return btrfsvol.Mapping{
 			LAddr: laddr,
 			PAddr: paddr,
-			Size:  CSumBlockSize,
+			Size:  btrfsitem.CSumBlockSize,
 		}, true
 	}
 	mapping := btrfsvol.Mapping{
@@ -212,7 +213,7 @@ func (em *ExtentMappings) considerMapping(ctx context.Context, laddr btrfsvol.Lo
 		return btrfsvol.Mapping{}, false
 	}
 
-	for offset := btrfsvol.AddrDelta(0); offset <= mapping.Size; offset += CSumBlockSize {
+	for offset := btrfsvol.AddrDelta(0); offset <= mapping.Size; offset += btrfsitem.CSumBlockSize {
 		expCSum, ok := em.InSums.SumForLAddr(mapping.LAddr.Add(offset))
 		if !ok {
 			continue
@@ -250,7 +251,7 @@ func (em *ExtentMappings) ScanOneDevice(
 	dlog.Infof(ctx, "... dev[%q] Scanning for extents...", devName)
 
 	var totalMappings int
-	_ = WalkGaps(ctx, gaps, CSumBlockSize,
+	_ = WalkGaps(ctx, gaps, btrfsitem.CSumBlockSize,
 		func(_, _ int64) {},
 		func(paddr btrfsvol.PhysicalAddr) error {
 			qpaddr := btrfsvol.QualifiedPhysicalAddr{
@@ -274,7 +275,7 @@ func (em *ExtentMappings) ScanOneDevice(
 			lastProgress = pct
 		}
 	}
-	return WalkGaps(ctx, gaps, CSumBlockSize,
+	return WalkGaps(ctx, gaps, btrfsitem.CSumBlockSize,
 		func(_, _ int64) {
 			progress()
 		},