bcachefs/get.go - external/github.com/prometheus/procfs - Git at Google

 // Copyright The Prometheus Authors
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 package bcachefs

 import (
 	"bufio"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
 	"strings"

 	"github.com/prometheus/procfs/internal/fs"
 	"github.com/prometheus/procfs/internal/util"
 )

 // FS represents the pseudo-filesystem sys, which provides an interface to
 // kernel data structures.
 type FS struct {
 	sys *fs.FS
 }

 // NewDefaultFS returns a new Bcachefs using the default sys fs mount point. It will error
 // if the mount point can't be read.
 func NewDefaultFS() (FS, error) {
 	return NewFS(fs.DefaultSysMountPoint)
 }

 // NewFS returns a new Bcachefs filesystem using the given sys fs mount point. It will error
 // if the mount point can't be read.
 func NewFS(mountPoint string) (FS, error) {
 	if strings.TrimSpace(mountPoint) == "" {
 		mountPoint = fs.DefaultSysMountPoint
 	}
 	sys, err := fs.NewFS(mountPoint)
 	if err != nil {
 		return FS{}, err
 	}
 	return FS{&sys}, nil
 }

 // Stats retrieves Bcachefs filesystem runtime statistics for each mounted Bcachefs filesystem.
 func (fs FS) Stats() ([]*Stats, error) {
 	base := fs.sys.Path("fs/bcachefs")
 	entries, err := os.ReadDir(base)
 	if err != nil {
 		return nil, err
 	}

 	stats := make([]*Stats, 0, len(entries))
 	for _, entry := range entries {
 		if !entry.IsDir() {
 			continue
 		}
 		uuidPath := filepath.Join(base, entry.Name())
 		s, err := GetStats(uuidPath)
 		if err != nil {
 			return nil, err
 		}
 		s.UUID = entry.Name()
 		stats = append(stats, s)
 	}

 	return stats, nil
 }

 // GetStats collects all Bcachefs statistics from sysfs.
 func GetStats(uuidPath string) (*Stats, error) {
 	r := &reader{path: uuidPath}
 	s := r.readFilesystemStats()
 	if r.err != nil {
 		return nil, r.err
 	}
 	return s, nil
 }

 type reader struct {
 	path string
 	err  error
 }

 // readFile reads a file relative to the path of the reader.
 // Non-existing files are ignored.
 func (r *reader) readFile(n string) string {
 	if r.err != nil {
 		return ""
 	}
 	b, err := util.ReadFileNoStat(filepath.Join(r.path, n))
 	if err != nil {
 		if !os.IsNotExist(err) {
 			r.err = err
 		}
 		return ""
 	}
 	return strings.TrimSpace(string(b))
 }

 func (r *reader) readHumanBytes(n string) uint64 {
 	s := r.readFile(n)
 	if r.err != nil || s == "" {
 		return 0
 	}
 	v, err := parseHumanReadableBytes(s)
 	if err != nil {
 		r.err = err
 		return 0
 	}
 	return v
 }

 func (r *reader) readFilesystemStats() *Stats {
 	stats := &Stats{
 		Compression: make(map[string]CompressionStats),
 		Errors:      make(map[string]ErrorStats),
 		Counters:    make(map[string]CounterStats),
 		BtreeWrites: make(map[string]BtreeWriteStats),
 		Devices:     make(map[string]*DeviceStats),
 	}

 	stats.BtreeCacheSizeBytes = r.readHumanBytes("btree_cache_size")

 	if r.err != nil {
 		return stats
 	}

 	comp, err := parseCompressionStats(filepath.Join(r.path, "compression_stats"))
 	if err != nil {
 		r.err = err
 		return stats
 	}
 	stats.Compression = comp

 	errs, err := parseErrors(filepath.Join(r.path, "errors"))
 	if err != nil {
 		r.err = err
 		return stats
 	}
 	stats.Errors = errs

 	counters, err := parseCounters(filepath.Join(r.path, "counters"))
 	if err != nil {
 		r.err = err
 		return stats
 	}
 	stats.Counters = counters

 	writes, err := parseBtreeWriteStats(filepath.Join(r.path, "btree_write_stats"))
 	if err != nil {
 		r.err = err
 		return stats
 	}
 	stats.BtreeWrites = writes

 	devices, err := parseDevices(r.path)
 	if err != nil {
 		r.err = err
 		return stats
 	}
 	stats.Devices = devices

 	return stats
 }

 func parseHumanReadableBytes(s string) (uint64, error) {
 	s = strings.TrimSpace(s)
 	if s == "" {
 		return 0, fmt.Errorf("empty string")
 	}

 	multiplier := float64(1)
 	lastChar := s[len(s)-1]
 	switch lastChar {
 	case 'k', 'K':
 		multiplier = 1024
 		s = s[:len(s)-1]
 	case 'm', 'M':
 		multiplier = 1024 * 1024
 		s = s[:len(s)-1]
 	case 'g', 'G':
 		multiplier = 1024 * 1024 * 1024
 		s = s[:len(s)-1]
 	case 't', 'T':
 		multiplier = 1024 * 1024 * 1024 * 1024
 		s = s[:len(s)-1]
 	case 'p', 'P':
 		multiplier = 1024 * 1024 * 1024 * 1024 * 1024
 		s = s[:len(s)-1]
 	case 'e', 'E':
 		multiplier = 1024 * 1024 * 1024 * 1024 * 1024 * 1024
 		s = s[:len(s)-1]
 	}

 	value, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
 	if err != nil {
 		return 0, err
 	}
 	return uint64(value * multiplier), nil
 }

 func parseCompressionStats(path string) (map[string]CompressionStats, error) {
 	file, err := openIfExists(path)
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
 		return map[string]CompressionStats{}, nil
 	}
 	defer file.Close()

 	stats := make(map[string]CompressionStats)

 	scanner := bufio.NewScanner(file)
 	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
 	lineNum := 0
 	for scanner.Scan() {
 		lineNum++
 		line := scanner.Text()
 		if lineNum == 1 {
 			continue
 		}
 		fields := strings.Fields(line)
 		if len(fields) < 3 {
 			continue
 		}
 		algorithm := strings.TrimSuffix(fields[0], ":")
 		compressed, err := parseHumanReadableBytes(fields[1])
 		if err != nil {
 			return nil, err
 		}
 		uncompressed, err := parseHumanReadableBytes(fields[2])
 		if err != nil {
 			return nil, err
 		}
 		var avgExtent uint64
 		if len(fields) >= 4 {
 			avgExtent, err = parseHumanReadableBytes(fields[3])
 			if err != nil {
 				return nil, err
 			}
 		}
 		stats[algorithm] = CompressionStats{
 			CompressedBytes:        compressed,
 			UncompressedBytes:      uncompressed,
 			AverageExtentSizeBytes: avgExtent,
 		}
 	}
 	if err := scanner.Err(); err != nil {
 		return nil, err
 	}
 	return stats, nil
 }

 func parseErrors(path string) (map[string]ErrorStats, error) {
 	file, err := openIfExists(path)
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
 		return map[string]ErrorStats{}, nil
 	}
 	defer file.Close()

 	stats := make(map[string]ErrorStats)

 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
 		line := scanner.Text()
 		fields := strings.Fields(line)
 		if len(fields) < 2 {
 			continue
 		}
 		count, err := strconv.ParseUint(fields[1], 10, 64)
 		if err != nil {
 			return nil, err
 		}
 		var ts uint64
 		if len(fields) >= 3 {
 			ts, err = strconv.ParseUint(fields[2], 10, 64)
 			if err != nil {
 				return nil, err
 			}
 		}
 		stats[fields[0]] = ErrorStats{Count: count, Timestamp: ts}
 	}
 	if err := scanner.Err(); err != nil {
 		return nil, err
 	}
 	return stats, nil
 }

 func parseCounters(countersPath string) (map[string]CounterStats, error) {
 	entries, err := os.ReadDir(countersPath)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
 		}
 		return nil, err
 	}

 	stats := make(map[string]CounterStats, len(entries))
 	for _, entry := range entries {
 		if entry.IsDir() {
 			continue
 		}
 		counterPath := filepath.Join(countersPath, entry.Name())
 		counter, err := parseCounterFile(counterPath)
 		if err != nil {
 			return nil, err
 		}
 		stats[entry.Name()] = counter
 	}

 	return stats, nil
 }

 func parseCounterFile(path string) (CounterStats, error) {
 	file, err := openIfExists(path)
 	if err != nil || file == nil {
 		return CounterStats{}, err
 	}
 	defer file.Close()

 	var stats CounterStats
 	var seenCreation bool
 	var seenMount bool

 	scanner := bufio.NewScanner(file)
 	for scanner.Scan() {
 		line := scanner.Text()
 		if valueStr, ok := strings.CutPrefix(line, "since mount:"); ok {
 			value, err := parseHumanReadableBytes(valueStr)
 			if err != nil {
 				return CounterStats{}, err
 			}
 			stats.SinceMount = value
 			seenMount = true
 			continue
 		}
 		if valueStr, ok := strings.CutPrefix(line, "since filesystem creation:"); ok {
 			value, err := parseHumanReadableBytes(valueStr)
 			if err != nil {
 				return CounterStats{}, err
 			}
 			stats.SinceFilesystemCreation = value
 			seenCreation = true
 			continue
 		}
 	}
 	if err := scanner.Err(); err != nil {
 		return CounterStats{}, err
 	}
 	if !seenCreation && !seenMount {
 		return CounterStats{}, fmt.Errorf("counter file format not recognized")
 	}
 	return stats, nil
 }

 func parseBtreeWriteStats(path string) (map[string]BtreeWriteStats, error) {
 	file, err := openIfExists(path)
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
 		return map[string]BtreeWriteStats{}, nil
 	}
 	defer file.Close()

 	stats := make(map[string]BtreeWriteStats)
 	scanner := bufio.NewScanner(file)
 	scanner.Buffer(make([]byte, 0, 64*1024), 1024*1024)
 	lineNum := 0
 	for scanner.Scan() {
 		lineNum++
 		line := scanner.Text()
 		if lineNum == 1 {
 			continue
 		}
 		fields := strings.Fields(line)
 		if len(fields) < 3 {
 			continue
 		}
 		writeType := strings.TrimSuffix(fields[0], ":")
 		count, err := strconv.ParseUint(fields[1], 10, 64)
 		if err != nil {
 			return nil, err
 		}
 		size, err := parseHumanReadableBytes(fields[2])
 		if err != nil {
 			return nil, err
 		}
 		stats[writeType] = BtreeWriteStats{Count: count, SizeBytes: size}
 	}
 	if err := scanner.Err(); err != nil {
 		return nil, err
 	}
 	return stats, nil
 }

 func parseDevices(fsPath string) (map[string]*DeviceStats, error) {
 	entries, err := os.ReadDir(fsPath)
 	if err != nil {
 		return nil, err
 	}

 	devices := make(map[string]*DeviceStats)
 	for _, entry := range entries {
 		if !entry.IsDir() || !strings.HasPrefix(entry.Name(), "dev-") {
 			continue
 		}
 		device := strings.TrimPrefix(entry.Name(), "dev-")
 		devPath := filepath.Join(fsPath, entry.Name())

 		stats := &DeviceStats{
 			Label:    readSysfsFile(filepath.Join(devPath, "label")),
 			State:    readSysfsFile(filepath.Join(devPath, "state")),
 			IODone:   make(map[string]map[string]uint64),
 			IOErrors: make(map[string]uint64),
 		}

 		if bucketSizeRaw := readSysfsFile(filepath.Join(devPath, "bucket_size")); bucketSizeRaw != "" {
 			bucketSize, err := parseHumanReadableBytes(bucketSizeRaw)
 			if err != nil {
 				return nil, err
 			}
 			stats.BucketSizeBytes = bucketSize
 		}

 		nbuckets, err := readUintFile(filepath.Join(devPath, "nbuckets"))
 		if err != nil {
 			return nil, err
 		}
 		stats.Buckets = nbuckets

 		durability, err := readUintFile(filepath.Join(devPath, "durability"))
 		if err != nil {
 			return nil, err
 		}
 		stats.Durability = durability

 		ioDone, err := parseDeviceIODone(filepath.Join(devPath, "io_done"))
 		if err != nil {
 			return nil, err
 		}
 		stats.IODone = ioDone

 		ioErrors, err := parseDeviceIOErrors(filepath.Join(devPath, "io_errors"))
 		if err != nil {
 			return nil, err
 		}
 		stats.IOErrors = ioErrors

 		devices[device] = stats
 	}

 	return devices, nil
 }

 func readSysfsFile(path string) string {
 	data, err := util.ReadFileNoStat(path)
 	if err != nil {
 		return ""
 	}
 	return strings.TrimSpace(string(data))
 }

 func readUintFile(path string) (uint64, error) {
 	data, err := util.ReadFileNoStat(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return 0, nil
 		}
 		return 0, err
 	}
 	return strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)
 }

 func parseDeviceIODone(path string) (map[string]map[string]uint64, error) {
 	file, err := openIfExists(path)
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
 		return map[string]map[string]uint64{}, nil
 	}
 	defer file.Close()

 	stats := make(map[string]map[string]uint64)
 	scanner := bufio.NewScanner(file)
 	var currentOp string

 	for scanner.Scan() {
 		line := strings.TrimSpace(scanner.Text())
 		if line == "" {
 			continue
 		}
 		if line == "read:" || line == "write:" {
 			currentOp = strings.TrimSuffix(line, ":")
 			if _, ok := stats[currentOp]; !ok {
 				stats[currentOp] = make(map[string]uint64)
 			}
 			continue
 		}
 		if currentOp == "" {
 			continue
 		}
 		parts := strings.SplitN(line, ":", 2)
 		if len(parts) != 2 {
 			continue
 		}
 		dataType := strings.TrimSpace(parts[0])
 		valueStr := strings.TrimSpace(parts[1])
 		value, err := strconv.ParseUint(valueStr, 10, 64)
 		if err != nil {
 			return nil, err
 		}
 		stats[currentOp][dataType] = value
 	}

 	if err := scanner.Err(); err != nil {
 		return nil, err
 	}
 	return stats, nil
 }

 func parseDeviceIOErrors(path string) (map[string]uint64, error) {
 	file, err := openIfExists(path)
 	if err != nil {
 		return nil, err
 	}
 	if file == nil {
 		return map[string]uint64{}, nil
 	}
 	defer file.Close()

 	stats := make(map[string]uint64)
 	scanner := bufio.NewScanner(file)
 	inCreationSection := false

 	for scanner.Scan() {
 		line := scanner.Text()
 		if strings.HasPrefix(line, "IO errors since filesystem creation") {
 			inCreationSection = true
 			continue
 		}
 		if strings.HasPrefix(line, "IO errors since ") {
 			break
 		}
 		if !inCreationSection {
 			continue
 		}
 		trimmed := strings.TrimSpace(line)
 		if trimmed == "" {
 			continue
 		}
 		parts := strings.SplitN(trimmed, ":", 2)
 		if len(parts) != 2 {
 			continue
 		}
 		errorType := strings.TrimSpace(parts[0])
 		valueStr := strings.TrimSpace(parts[1])
 		value, err := strconv.ParseUint(valueStr, 10, 64)
 		if err != nil {
 			return nil, err
 		}
 		stats[errorType] = value
 	}

 	if err := scanner.Err(); err != nil {
 		return nil, err
 	}
 	return stats, nil
 }

 func openIfExists(path string) (*os.File, error) {
 	file, err := os.Open(path)
 	if err != nil {
 		if os.IsNotExist(err) {
 			return nil, nil
 		}
 		return nil, err
 	}
 	return file, nil
 }
	// Copyright The Prometheus Authors
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	package bcachefs

	import (
	"bufio"
	"fmt"
	"os"
	"path/filepath"
	"strconv"
	"strings"

	"github.com/prometheus/procfs/internal/fs"
	"github.com/prometheus/procfs/internal/util"
	)

	// FS represents the pseudo-filesystem sys, which provides an interface to
	// kernel data structures.
	type FS struct {
	sys *fs.FS
	}

	// NewDefaultFS returns a new Bcachefs using the default sys fs mount point. It will error
	// if the mount point can't be read.
	func NewDefaultFS() (FS, error) {
	return NewFS(fs.DefaultSysMountPoint)
	}

	// NewFS returns a new Bcachefs filesystem using the given sys fs mount point. It will error
	// if the mount point can't be read.
	func NewFS(mountPoint string) (FS, error) {
	if strings.TrimSpace(mountPoint) == "" {
	mountPoint = fs.DefaultSysMountPoint
	}
	sys, err := fs.NewFS(mountPoint)
	if err != nil {
	return FS{}, err
	}
	return FS{&sys}, nil
	}

	// Stats retrieves Bcachefs filesystem runtime statistics for each mounted Bcachefs filesystem.
	func (fs FS) Stats() ([]*Stats, error) {
	base := fs.sys.Path("fs/bcachefs")
	entries, err := os.ReadDir(base)
	if err != nil {
	return nil, err
	}

	stats := make([]*Stats, 0, len(entries))
	for _, entry := range entries {
	if !entry.IsDir() {
	continue
	}
	uuidPath := filepath.Join(base, entry.Name())
	s, err := GetStats(uuidPath)
	if err != nil {
	return nil, err
	}
	s.UUID = entry.Name()
	stats = append(stats, s)
	}

	return stats, nil
	}

	// GetStats collects all Bcachefs statistics from sysfs.
	func GetStats(uuidPath string) (*Stats, error) {
	r := &reader{path: uuidPath}
	s := r.readFilesystemStats()
	if r.err != nil {
	return nil, r.err
	}
	return s, nil
	}

	type reader struct {
	path string
	err error
	}

	// readFile reads a file relative to the path of the reader.
	// Non-existing files are ignored.
	func (r *reader) readFile(n string) string {
	if r.err != nil {
	return ""
	}
	b, err := util.ReadFileNoStat(filepath.Join(r.path, n))
	if err != nil {
	if !os.IsNotExist(err) {
	r.err = err
	}
	return ""
	}
	return strings.TrimSpace(string(b))
	}

	func (r *reader) readHumanBytes(n string) uint64 {
	s := r.readFile(n)
	if r.err != nil \|\| s == "" {
	return 0
	}
	v, err := parseHumanReadableBytes(s)
	if err != nil {
	r.err = err
	return 0
	}
	return v
	}

	func (r reader) readFilesystemStats() Stats {
	stats := &Stats{
	Compression: make(map[string]CompressionStats),
	Errors: make(map[string]ErrorStats),
	Counters: make(map[string]CounterStats),
	BtreeWrites: make(map[string]BtreeWriteStats),
	Devices: make(map[string]*DeviceStats),
	}

	stats.BtreeCacheSizeBytes = r.readHumanBytes("btree_cache_size")

	if r.err != nil {
	return stats
	}

	comp, err := parseCompressionStats(filepath.Join(r.path, "compression_stats"))
	if err != nil {
	r.err = err
	return stats
	}
	stats.Compression = comp

	errs, err := parseErrors(filepath.Join(r.path, "errors"))
	if err != nil {
	r.err = err
	return stats
	}
	stats.Errors = errs

	counters, err := parseCounters(filepath.Join(r.path, "counters"))
	if err != nil {
	r.err = err
	return stats
	}
	stats.Counters = counters

	writes, err := parseBtreeWriteStats(filepath.Join(r.path, "btree_write_stats"))
	if err != nil {
	r.err = err
	return stats
	}
	stats.BtreeWrites = writes

	devices, err := parseDevices(r.path)
	if err != nil {
	r.err = err
	return stats
	}
	stats.Devices = devices

	return stats
	}

	func parseHumanReadableBytes(s string) (uint64, error) {
	s = strings.TrimSpace(s)
	if s == "" {
	return 0, fmt.Errorf("empty string")
	}

	multiplier := float64(1)
	lastChar := s[len(s)-1]
	switch lastChar {
	case 'k', 'K':
	multiplier = 1024
	s = s[:len(s)-1]
	case 'm', 'M':
	multiplier = 1024 * 1024
	s = s[:len(s)-1]
	case 'g', 'G':
	multiplier = 1024 * 1024 * 1024
	s = s[:len(s)-1]
	case 't', 'T':
	multiplier = 1024 * 1024 * 1024 * 1024
	s = s[:len(s)-1]
	case 'p', 'P':
	multiplier = 1024 * 1024 * 1024 * 1024 * 1024
	s = s[:len(s)-1]
	case 'e', 'E':
	multiplier = 1024 * 1024 * 1024 * 1024 * 1024 * 1024
	s = s[:len(s)-1]
	}

	value, err := strconv.ParseFloat(strings.TrimSpace(s), 64)
	if err != nil {
	return 0, err
	}
	return uint64(value * multiplier), nil
	}

	func parseCompressionStats(path string) (map[string]CompressionStats, error) {
	file, err := openIfExists(path)
	if err != nil {
	return nil, err
	}
	if file == nil {
	return map[string]CompressionStats{}, nil
	}
	defer file.Close()

	stats := make(map[string]CompressionStats)

	scanner := bufio.NewScanner(file)
	scanner.Buffer(make([]byte, 0, 641024), 10241024)
	lineNum := 0
	for scanner.Scan() {
	lineNum++
	line := scanner.Text()
	if lineNum == 1 {
	continue
	}
	fields := strings.Fields(line)
	if len(fields) < 3 {
	continue
	}
	algorithm := strings.TrimSuffix(fields[0], ":")
	compressed, err := parseHumanReadableBytes(fields[1])
	if err != nil {
	return nil, err
	}
	uncompressed, err := parseHumanReadableBytes(fields[2])
	if err != nil {
	return nil, err
	}
	var avgExtent uint64
	if len(fields) >= 4 {
	avgExtent, err = parseHumanReadableBytes(fields[3])
	if err != nil {
	return nil, err
	}
	}
	stats[algorithm] = CompressionStats{
	CompressedBytes: compressed,
	UncompressedBytes: uncompressed,
	AverageExtentSizeBytes: avgExtent,
	}
	}
	if err := scanner.Err(); err != nil {
	return nil, err
	}
	return stats, nil
	}

	func parseErrors(path string) (map[string]ErrorStats, error) {
	file, err := openIfExists(path)
	if err != nil {
	return nil, err
	}
	if file == nil {
	return map[string]ErrorStats{}, nil
	}
	defer file.Close()

	stats := make(map[string]ErrorStats)

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
	line := scanner.Text()
	fields := strings.Fields(line)
	if len(fields) < 2 {
	continue
	}
	count, err := strconv.ParseUint(fields[1], 10, 64)
	if err != nil {
	return nil, err
	}
	var ts uint64
	if len(fields) >= 3 {
	ts, err = strconv.ParseUint(fields[2], 10, 64)
	if err != nil {
	return nil, err
	}
	}
	stats[fields[0]] = ErrorStats{Count: count, Timestamp: ts}
	}
	if err := scanner.Err(); err != nil {
	return nil, err
	}
	return stats, nil
	}

	func parseCounters(countersPath string) (map[string]CounterStats, error) {
	entries, err := os.ReadDir(countersPath)
	if err != nil {
	if os.IsNotExist(err) {
	return nil, nil
	}
	return nil, err
	}

	stats := make(map[string]CounterStats, len(entries))
	for _, entry := range entries {
	if entry.IsDir() {
	continue
	}
	counterPath := filepath.Join(countersPath, entry.Name())
	counter, err := parseCounterFile(counterPath)
	if err != nil {
	return nil, err
	}
	stats[entry.Name()] = counter
	}

	return stats, nil
	}

	func parseCounterFile(path string) (CounterStats, error) {
	file, err := openIfExists(path)
	if err != nil \|\| file == nil {
	return CounterStats{}, err
	}
	defer file.Close()

	var stats CounterStats
	var seenCreation bool
	var seenMount bool

	scanner := bufio.NewScanner(file)
	for scanner.Scan() {
	line := scanner.Text()
	if valueStr, ok := strings.CutPrefix(line, "since mount:"); ok {
	value, err := parseHumanReadableBytes(valueStr)
	if err != nil {
	return CounterStats{}, err
	}
	stats.SinceMount = value
	seenMount = true
	continue
	}
	if valueStr, ok := strings.CutPrefix(line, "since filesystem creation:"); ok {
	value, err := parseHumanReadableBytes(valueStr)
	if err != nil {
	return CounterStats{}, err
	}
	stats.SinceFilesystemCreation = value
	seenCreation = true
	continue
	}
	}
	if err := scanner.Err(); err != nil {
	return CounterStats{}, err
	}
	if !seenCreation && !seenMount {
	return CounterStats{}, fmt.Errorf("counter file format not recognized")
	}
	return stats, nil
	}

	func parseBtreeWriteStats(path string) (map[string]BtreeWriteStats, error) {
	file, err := openIfExists(path)
	if err != nil {
	return nil, err
	}
	if file == nil {
	return map[string]BtreeWriteStats{}, nil
	}
	defer file.Close()

	stats := make(map[string]BtreeWriteStats)
	scanner := bufio.NewScanner(file)
	scanner.Buffer(make([]byte, 0, 641024), 10241024)
	lineNum := 0
	for scanner.Scan() {
	lineNum++
	line := scanner.Text()
	if lineNum == 1 {
	continue
	}
	fields := strings.Fields(line)
	if len(fields) < 3 {
	continue
	}
	writeType := strings.TrimSuffix(fields[0], ":")
	count, err := strconv.ParseUint(fields[1], 10, 64)
	if err != nil {
	return nil, err
	}
	size, err := parseHumanReadableBytes(fields[2])
	if err != nil {
	return nil, err
	}
	stats[writeType] = BtreeWriteStats{Count: count, SizeBytes: size}
	}
	if err := scanner.Err(); err != nil {
	return nil, err
	}
	return stats, nil
	}

	func parseDevices(fsPath string) (map[string]*DeviceStats, error) {
	entries, err := os.ReadDir(fsPath)
	if err != nil {
	return nil, err
	}

	devices := make(map[string]*DeviceStats)
	for _, entry := range entries {
	if !entry.IsDir() \|\| !strings.HasPrefix(entry.Name(), "dev-") {
	continue
	}
	device := strings.TrimPrefix(entry.Name(), "dev-")
	devPath := filepath.Join(fsPath, entry.Name())

	stats := &DeviceStats{
	Label: readSysfsFile(filepath.Join(devPath, "label")),
	State: readSysfsFile(filepath.Join(devPath, "state")),
	IODone: make(map[string]map[string]uint64),
	IOErrors: make(map[string]uint64),
	}

	if bucketSizeRaw := readSysfsFile(filepath.Join(devPath, "bucket_size")); bucketSizeRaw != "" {
	bucketSize, err := parseHumanReadableBytes(bucketSizeRaw)
	if err != nil {
	return nil, err
	}
	stats.BucketSizeBytes = bucketSize
	}

	nbuckets, err := readUintFile(filepath.Join(devPath, "nbuckets"))
	if err != nil {
	return nil, err
	}
	stats.Buckets = nbuckets

	durability, err := readUintFile(filepath.Join(devPath, "durability"))
	if err != nil {
	return nil, err
	}
	stats.Durability = durability

	ioDone, err := parseDeviceIODone(filepath.Join(devPath, "io_done"))
	if err != nil {
	return nil, err
	}
	stats.IODone = ioDone

	ioErrors, err := parseDeviceIOErrors(filepath.Join(devPath, "io_errors"))
	if err != nil {
	return nil, err
	}
	stats.IOErrors = ioErrors

	devices[device] = stats
	}

	return devices, nil
	}

	func readSysfsFile(path string) string {
	data, err := util.ReadFileNoStat(path)
	if err != nil {
	return ""
	}
	return strings.TrimSpace(string(data))
	}

	func readUintFile(path string) (uint64, error) {
	data, err := util.ReadFileNoStat(path)
	if err != nil {
	if os.IsNotExist(err) {
	return 0, nil
	}
	return 0, err
	}
	return strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)
	}

	func parseDeviceIODone(path string) (map[string]map[string]uint64, error) {
	file, err := openIfExists(path)
	if err != nil {
	return nil, err
	}
	if file == nil {
	return map[string]map[string]uint64{}, nil
	}
	defer file.Close()

	stats := make(map[string]map[string]uint64)
	scanner := bufio.NewScanner(file)
	var currentOp string

	for scanner.Scan() {
	line := strings.TrimSpace(scanner.Text())
	if line == "" {
	continue
	}
	if line == "read:" \|\| line == "write:" {
	currentOp = strings.TrimSuffix(line, ":")
	if _, ok := stats[currentOp]; !ok {
	stats[currentOp] = make(map[string]uint64)
	}
	continue
	}
	if currentOp == "" {
	continue
	}
	parts := strings.SplitN(line, ":", 2)
	if len(parts) != 2 {
	continue
	}
	dataType := strings.TrimSpace(parts[0])
	valueStr := strings.TrimSpace(parts[1])
	value, err := strconv.ParseUint(valueStr, 10, 64)
	if err != nil {
	return nil, err
	}
	stats[currentOp][dataType] = value
	}

	if err := scanner.Err(); err != nil {
	return nil, err
	}
	return stats, nil
	}

	func parseDeviceIOErrors(path string) (map[string]uint64, error) {
	file, err := openIfExists(path)
	if err != nil {
	return nil, err
	}
	if file == nil {
	return map[string]uint64{}, nil
	}
	defer file.Close()

	stats := make(map[string]uint64)
	scanner := bufio.NewScanner(file)
	inCreationSection := false

	for scanner.Scan() {
	line := scanner.Text()
	if strings.HasPrefix(line, "IO errors since filesystem creation") {
	inCreationSection = true
	continue
	}
	if strings.HasPrefix(line, "IO errors since ") {
	break
	}
	if !inCreationSection {
	continue
	}
	trimmed := strings.TrimSpace(line)
	if trimmed == "" {
	continue
	}
	parts := strings.SplitN(trimmed, ":", 2)
	if len(parts) != 2 {
	continue
	}
	errorType := strings.TrimSpace(parts[0])
	valueStr := strings.TrimSpace(parts[1])
	value, err := strconv.ParseUint(valueStr, 10, 64)
	if err != nil {
	return nil, err
	}
	stats[errorType] = value
	}

	if err := scanner.Err(); err != nil {
	return nil, err
	}
	return stats, nil
	}

	func openIfExists(path string) (*os.File, error) {
	file, err := os.Open(path)
	if err != nil {
	if os.IsNotExist(err) {
	return nil, nil
	}
	return nil, err
	}
	return file, nil
	}