Squashing commits

Signed-off-by: Muhammad Shahzeb <mhmdshahzeb1993@gmail.com>

.github/workflows/golangci-lint.yml

@@ -26,7 +26,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
       - name: Install Go
-        uses: actions/setup-go@0c52d547c9bc32b1aa3301fd7a9cb496313a4491 # v5.0.0
+        uses: actions/setup-go@cdcb36043654635271a94b9a6d1392de5bb323a7 # v5.0.1
         with:
           go-version: 1.22.x
       - name: Install snmp_exporter/generator dependencies

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/<disk>/device/iodone_cnt
+// IO error count: /sys/block/<disk>/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
+}

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
+}

go.mod

@@ -5,5 +5,5 @@ go 1.20
 require (
 	github.com/google/go-cmp v0.6.0
 	golang.org/x/sync v0.7.0
-	golang.org/x/sys v0.20.0
+	golang.org/x/sys v0.21.0
 )

go.sum

@@ -2,5 +2,5 @@ github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
 golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws=
+golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

internal/util/parse.go

@@ -110,3 +110,12 @@ 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
+	}
+	return strconv.ParseUint(strings.TrimSpace(string(data[2:])), 16, 64)
+}

proc_status.go

@@ -146,7 +146,11 @@ func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintByt
 			}
 		}
 	case "NSpid":
-		s.NSpids = calcNSPidsList(vString)
+		nspids, err := calcNSPidsList(vString)
+		if err != nil {
+			return err
+		}
+		s.NSpids = nspids
 	case "VmPeak":
 		s.VmPeak = vUintBytes
 	case "VmSize":
@@ -222,17 +226,17 @@ func calcCpusAllowedList(cpuString string) []uint64 {
 	return g
 }
 
-func calcNSPidsList(nspidsString string) []uint64 {
-	s := strings.Split(nspidsString, " ")
+func calcNSPidsList(nspidsString string) ([]uint64, error) {
+	s := strings.Split(nspidsString, "\t")
 	var nspids []uint64
 
 	for _, nspid := range s {
-		nspid, _ := strconv.ParseUint(nspid, 10, 64)
-		if nspid == 0 {
-			continue
+		nspid, err := strconv.ParseUint(nspid, 10, 64)
+		if err != nil {
+			return nil, err
 		}
 		nspids = append(nspids, nspid)
 	}
 
-	return nspids
+	return nspids, nil
 }

proc_status_test.go

@@ -139,3 +139,19 @@ func TestCpusAllowedList(t *testing.T) {
 		t.Errorf("want CpusAllowedList %v, have %v", want, have)
 	}
 }
+
+func TestNsPids(t *testing.T) {
+	p, err := getProcFixtures(t).Proc(26235)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	s, err := p.NewStatus()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if want, have := []uint64{26235, 1}, s.NSpids; !reflect.DeepEqual(want, have) {
+		t.Errorf("want NsPids %v, have %v", want, have)
+	}
+}

testdata/fixtures.ttar

@@ -818,10 +818,10 @@ Uid:	0	0	0	0
 Gid:	0	0	0	0
 FDSize: 64
 Groups:
-NStgid: 26235   1
-NSpid:  26235   1
-NSpgid: 26235   1
-NSsid:  26235   1
+NStgid: 26235	1
+NSpid:  26235	1
+NSpgid: 26235	1
+NSsid:  26235	1
 VmPeak:   758200 kB
 VmSize:   758200 kB
 VmLck:         0 kB