export CSumBlockSize

4 files changed, 25 insertions, 25 deletions

diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go b/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
index 3a3192d..5ec87d9 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/csums.go
@@ -24,7 +24,7 @@ import (
 	"git.lukeshu.com/btrfs-progs-ng/lib/btrfsprogs/btrfsutil"
 )
 
-const csumBlockSize = 4 * 1024
+const CSumBlockSize = 4 * 1024
 
 // ShortSum //////////////////////////////////////////////////////////
 
@@ -49,7 +49,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()) * CSumBlockSize
 }
 
 // Get implements diskio.Sequence[int, ShortSum]
@@ -65,12 +65,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)/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+CSumBlockSize, off+run.ChecksumSize {
 		if err := ctx.Err(); err != nil {
 			return err
 		}
@@ -180,8 +180,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) * CSumBlockSize)
+						if laddr != curAddr+(btrfsvol.LogicalAddr(curSums.Len()/csumSize)*CSumBlockSize) {
 							if curSums.Len() > 0 {
 								ret.Logical = append(ret.Logical, SumRun[btrfsvol.LogicalAddr]{
 									ChecksumSize: csumSize,
@@ -226,7 +226,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 / CSumBlockSize)
 				sums := make([]byte, numSums*csumSize)
 				lastPct := -1
 				progress := func(curSum int) {
@@ -242,7 +242,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*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 14be110..83277dd 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 [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 [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*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)*CSumBlockSize)] = sum
 	}
 	return ret, nil
 }
diff --git a/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go b/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
index 5963e53..1540a2e 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/gaps.go
@@ -62,9 +62,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, CSumBlockSize)
+			begOff := int(begAddr/CSumBlockSize) * sums.Physical[devID].ChecksumSize
+			endOff := int(gap.End/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 3aeb05a..64e0871 100644
--- a/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go
+++ b/lib/btrfsprogs/btrfsinspect/scanforextents/scan.go
@@ -29,11 +29,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)/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)*CSumBlockSize)
+			deltaOff := int(deltaAddr/CSumBlockSize) * run.ChecksumSize
 			bgSums[blockgroup.LAddr] = append(bgSums[blockgroup.LAddr], SumRun[btrfsvol.LogicalAddr]{
 				ChecksumSize: run.ChecksumSize,
 				Addr:         laddr,
@@ -67,7 +67,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) * CSumBlockSize),
 				})
 			}
 			return nil
@@ -106,7 +106,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 [CSumBlockSize]byte
 		if _, err := fs.ReadAt(dat[:], laddr); err != nil {
 			if errors.Is(err, btrfsvol.ErrCouldNotMap) {
 				sum2laddrs[sum] = append(sum2laddrs[sum], laddr)
@@ -179,12 +179,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, CSumBlockSize)
 	if blockgroup == nil {
 		return btrfsvol.Mapping{
 			LAddr: laddr,
 			PAddr: paddr,
-			Size:  csumBlockSize,
+			Size:  CSumBlockSize,
 		}, true
 	}
 	mapping := btrfsvol.Mapping{
@@ -204,7 +204,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 += CSumBlockSize {
 		expCSum, ok := em.InSums.SumForLAddr(mapping.LAddr.Add(offset))
 		if !ok {
 			continue
@@ -242,7 +242,7 @@ func (em *ExtentMappings) ScanOneDev(
 	dlog.Infof(ctx, "... dev[%q] Scanning for extents...", devName)
 
 	var totalMappings int
-	_ = WalkGaps(ctx, gaps, csumBlockSize,
+	_ = WalkGaps(ctx, gaps, CSumBlockSize,
 		func(_, _ int64) {},
 		func(paddr btrfsvol.PhysicalAddr) error {
 			qpaddr := btrfsvol.QualifiedPhysicalAddr{
@@ -266,7 +266,7 @@ func (em *ExtentMappings) ScanOneDev(
 			lastProgress = pct
 		}
 	}
-	return WalkGaps(ctx, gaps, csumBlockSize,
+	return WalkGaps(ctx, gaps, CSumBlockSize,
 		func(_, _ int64) {
 			progress()
 		},