From 6069bcb2c6cd2599278d2f6be1772f83994e37cc Mon Sep 17 00:00:00 2001 From: Muhammad Shahzeb Date: Tue, 16 Jul 2024 23:32:54 +0500 Subject: [PATCH] Add Disk IO stats and ext4 FS stats Adds function to return disk stats from: * /sys/block//device/ioerr_cnt: number of SCSI commands that completed with an error * /sys/block//device/iodone_cnt: number of completed or rejected SCSI commands Add function to return stats for ext4 filesystem * /sys/fs/ext4//errors_count: number of ext4 errors * /sys/fs/ext4//warning_count: number of ext4 warning log messages * /sys/fs/ext4//msg_count: number of other ext4 log messages Signed-off-by: Muhammad Shahzeb --- blockdevice/stats.go | 28 +++++++++++ ext4/ext4.go | 103 +++++++++++++++++++++++++++++++++++++++++ internal/util/parse.go | 14 ++++++ 3 files changed, 145 insertions(+) create mode 100644 ext4/ext4.go diff --git a/blockdevice/stats.go b/blockdevice/stats.go index 22533002d..75b68845a 100644 --- a/blockdevice/stats.go +++ b/blockdevice/stats.go @@ -178,6 +178,11 @@ type BlockQueueStats struct { WriteZeroesMaxBytes uint64 } +type IODeviceStats struct { + IODoneCount uint64 + IOErrCount uint64 +} + // DeviceMapperInfo models the devicemapper files that are located in the sysfs tree for each block device // and described in the kernel documentation: // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-block-dm @@ -209,6 +214,7 @@ const ( sysBlockQueue = "queue" sysBlockDM = "dm" sysUnderlyingDev = "slaves" + sysDevicePath = "device" ) // FS represents the pseudo-filesystems proc and sys, which provides an @@ -474,3 +480,25 @@ func (fs FS) SysBlockDeviceUnderlyingDevices(device string) (UnderlyingDeviceInf return UnderlyingDeviceInfo{DeviceNames: underlying}, nil } + +// SysBlockDeviceIO returns stats for the block device io counters +// IO done count: /sys/block//device/iodone_cnt +// IO error count: /sys/block//device/ioerr_cnt. +func (fs FS) SysBlockDeviceIOStat(device string) (IODeviceStats, error) { + var ( + ioDeviceStats IODeviceStats + err error + ) + for file, p := range map[string]*uint64{ + "iodone_cnt": &ioDeviceStats.IODoneCount, + "ioerr_cnt": &ioDeviceStats.IOErrCount, + } { + var val uint64 + val, err = util.ReadHexFromFile(fs.sys.Path(sysBlockPath, device, sysDevicePath, file)) + if err != nil { + return IODeviceStats{}, err + } + *p = val + } + return ioDeviceStats, nil +} diff --git a/ext4/ext4.go b/ext4/ext4.go new file mode 100644 index 000000000..b7f83a583 --- /dev/null +++ b/ext4/ext4.go @@ -0,0 +1,103 @@ +// Copyright 2019 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 btrfs provides access to statistics exposed by ext4 filesystems. +package ext4 + +import ( + "path/filepath" + "strings" + + "github.com/prometheus/procfs/internal/fs" + "github.com/prometheus/procfs/internal/util" +) + +const ( + sysFSPath = "fs" + sysFSExt4Path = "ext4" +) + +// Stats contains statistics for a single Btrfs filesystem. +// See Linux fs/btrfs/sysfs.c for more information. +type Stats struct { + Name string + + Errors uint64 + Warnings uint64 + Messages uint64 +} + +// FS represents the pseudo-filesystems proc and sys, which provides an +// interface to kernel data structures. +type FS struct { + proc *fs.FS + sys *fs.FS +} + +// NewDefaultFS returns a new blockdevice fs using the default mountPoints for proc and sys. +// It will error if either of these mount points can't be read. +func NewDefaultFS() (FS, error) { + return NewFS(fs.DefaultProcMountPoint, fs.DefaultSysMountPoint) +} + +// NewFS returns a new XFS handle using the given proc and sys mountPoints. It will error +// if either of the mounts point can't be read. +func NewFS(procMountPoint string, sysMountPoint string) (FS, error) { + if strings.TrimSpace(procMountPoint) == "" { + procMountPoint = fs.DefaultProcMountPoint + } + procfs, err := fs.NewFS(procMountPoint) + if err != nil { + return FS{}, err + } + if strings.TrimSpace(sysMountPoint) == "" { + sysMountPoint = fs.DefaultSysMountPoint + } + sysfs, err := fs.NewFS(sysMountPoint) + if err != nil { + return FS{}, err + } + return FS{&procfs, &sysfs}, nil +} + +// ProcStat returns stats for the filesystem. +func (fs FS) ProcStat() ([]*Stats, error) { + matches, err := filepath.Glob(fs.sys.Path("fs/ext4/*")) + if err != nil { + return nil, err + } + + stats := make([]*Stats, 0, len(matches)) + for _, m := range matches { + s := &Stats{} + + // "*" used in glob above indicates the name of the filesystem. + name := filepath.Base(m) + s.Name = name + for file, p := range map[string]*uint64{ + "errors_count": &s.Errors, + "warning_count": &s.Warnings, + "msg_count": &s.Messages, + } { + var val uint64 + val, err = util.ReadUintFromFile(fs.sys.Path(sysFSPath, sysFSExt4Path, name, file)) + if err == nil { + *p = val + } + } + + stats = append(stats, s) + } + + return stats, nil +} diff --git a/internal/util/parse.go b/internal/util/parse.go index 14272dc78..5a7d2df06 100644 --- a/internal/util/parse.go +++ b/internal/util/parse.go @@ -14,6 +14,7 @@ package util import ( + "errors" "os" "strconv" "strings" @@ -110,3 +111,16 @@ func ParseBool(b string) *bool { } return &truth } + +// ReadHexFromFile reads a file and attempts to parse a uint64 from a hexadecimal format 0xXX. +func ReadHexFromFile(path string) (uint64, error) { + data, err := os.ReadFile(path) + if err != nil { + return 0, err + } + hexString := strings.TrimSpace(string(data)) + if !strings.HasPrefix(hexString, "0x") { + return 0, errors.New("invalid format: hex string does not start with '0x'") + } + return strconv.ParseUint(hexString[2:], 16, 64) +}