Update dependencies

2025-10-12 13:55:23 +03:00
parent 897a2035d9
commit 3ad60b9c69
437 changed files with 26255 additions and 43246 deletions
--- a/vendor/github.com/prometheus/procfs/.golangci.yml
+++ b/vendor/github.com/prometheus/procfs/.golangci.yml
@@ -1,31 +1,12 @@
 ---
 linters:
  enable:
-  - errcheck
-  - forbidigo
  - godot
-  - gofmt
-  - goimports
-  - gosimple
-  - govet
-  - ineffassign
-  - misspell
  - revive
-  - staticcheck
-  - testifylint
-  - unused

-linters-settings:
-  forbidigo:
-    forbid:
-      - p: ^fmt\.Print.*$
-        msg: Do not commit print statements.
+linter-settings:
  godot:
    capital: true
    exclude:
    # Ignore "See: URL"
    - 'See:'
-  goimports:
-      local-prefixes: github.com/prometheus/procfs
-  misspell:
-    locale: US
--- a/vendor/github.com/prometheus/procfs/MAINTAINERS.md
+++ b/vendor/github.com/prometheus/procfs/MAINTAINERS.md
@@ -1,3 +1,2 @@
 * Johannes 'fish' Ziemke <github@freigeist.org> @discordianfish
-* Paul Gier <paulgier@gmail.com> @pgier
-* Ben Kochie <superq@gmail.com> @SuperQ
+* Paul Gier <pgier@redhat.com> @pgier
--- a/vendor/github.com/prometheus/procfs/Makefile.common
+++ b/vendor/github.com/prometheus/procfs/Makefile.common
@@ -49,23 +49,23 @@ endif
 GOTEST := $(GO) test
 GOTEST_DIR :=
 ifneq ($(CIRCLE_JOB),)
-ifneq ($(shell command -v gotestsum 2> /dev/null),)
+ifneq ($(shell which gotestsum),)
 	GOTEST_DIR := test-results
 	GOTEST := gotestsum --junitfile $(GOTEST_DIR)/unit-tests.xml --
 endif
 endif

-PROMU_VERSION ?= 0.17.0
+PROMU_VERSION ?= 0.14.0
 PROMU_URL     := https://github.com/prometheus/promu/releases/download/v$(PROMU_VERSION)/promu-$(PROMU_VERSION).$(GO_BUILD_PLATFORM).tar.gz

 SKIP_GOLANGCI_LINT :=
 GOLANGCI_LINT :=
 GOLANGCI_LINT_OPTS ?=
-GOLANGCI_LINT_VERSION ?= v1.60.2
-# golangci-lint only supports linux, darwin and windows platforms on i386/amd64/arm64.
+GOLANGCI_LINT_VERSION ?= v1.49.0
+# golangci-lint only supports linux, darwin and windows platforms on i386/amd64.
 # windows isn't included here because of the path separator being different.
 ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux darwin))
-	ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386 arm64))
+	ifeq ($(GOHOSTARCH),$(filter $(GOHOSTARCH),amd64 i386))
 		# If we're in CI and there is an Actions file, that means the linter
 		# is being run in Actions, so we don't need to run it here.
 		ifneq (,$(SKIP_GOLANGCI_LINT))
@@ -91,8 +91,6 @@ BUILD_DOCKER_ARCHS = $(addprefix common-docker-,$(DOCKER_ARCHS))
 PUBLISH_DOCKER_ARCHS = $(addprefix common-docker-publish-,$(DOCKER_ARCHS))
 TAG_DOCKER_ARCHS = $(addprefix common-docker-tag-latest-,$(DOCKER_ARCHS))

-SANITIZED_DOCKER_IMAGE_TAG := $(subst +,-,$(DOCKER_IMAGE_TAG))
-
 ifeq ($(GOHOSTARCH),amd64)
        ifeq ($(GOHOSTOS),$(filter $(GOHOSTOS),linux freebsd darwin windows))
                # Only supported on amd64
@@ -169,20 +167,16 @@ common-vet:
 common-lint: $(GOLANGCI_LINT)
 ifdef GOLANGCI_LINT
 	@echo ">> running golangci-lint"
+# 'go list' needs to be executed before staticcheck to prepopulate the modules cache.
+# Otherwise staticcheck might fail randomly for some reason not yet explained.
+	$(GO) list -e -compiled -test=true -export=false -deps=true -find=false -tags= -- ./... > /dev/null
 	$(GOLANGCI_LINT) run $(GOLANGCI_LINT_OPTS) $(pkgs)
 endif

-.PHONY: common-lint-fix
-common-lint-fix: $(GOLANGCI_LINT)
-ifdef GOLANGCI_LINT
-	@echo ">> running golangci-lint fix"
-	$(GOLANGCI_LINT) run --fix $(GOLANGCI_LINT_OPTS) $(pkgs)
-endif
-
 .PHONY: common-yamllint
 common-yamllint:
 	@echo ">> running yamllint on all YAML files in the repository"
-ifeq (, $(shell command -v yamllint 2> /dev/null))
+ifeq (, $(shell which yamllint))
 	@echo "yamllint not installed so skipping"
 else
 	yamllint .
@@ -208,14 +202,10 @@ common-tarball: promu
 	@echo ">> building release tarball"
 	$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR)

-.PHONY: common-docker-repo-name
-common-docker-repo-name:
-	@echo "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)"
-
 .PHONY: common-docker $(BUILD_DOCKER_ARCHS)
 common-docker: $(BUILD_DOCKER_ARCHS)
 $(BUILD_DOCKER_ARCHS): common-docker-%:
-	docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" \
+	docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" \
 		-f $(DOCKERFILE_PATH) \
 		--build-arg ARCH="$*" \
 		--build-arg OS="linux" \
@@ -224,19 +214,19 @@ $(BUILD_DOCKER_ARCHS): common-docker-%:
 .PHONY: common-docker-publish $(PUBLISH_DOCKER_ARCHS)
 common-docker-publish: $(PUBLISH_DOCKER_ARCHS)
 $(PUBLISH_DOCKER_ARCHS): common-docker-publish-%:
-	docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)"
+	docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)"

 DOCKER_MAJOR_VERSION_TAG = $(firstword $(subst ., ,$(shell cat VERSION)))
 .PHONY: common-docker-tag-latest $(TAG_DOCKER_ARCHS)
 common-docker-tag-latest: $(TAG_DOCKER_ARCHS)
 $(TAG_DOCKER_ARCHS): common-docker-tag-latest-%:
-	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"
-	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(SANITIZED_DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)"
+	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:latest"
+	docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$*:v$(DOCKER_MAJOR_VERSION_TAG)"

 .PHONY: common-docker-manifest
 common-docker-manifest:
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(SANITIZED_DOCKER_IMAGE_TAG))
-	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(SANITIZED_DOCKER_IMAGE_TAG)"
+	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest create -a "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" $(foreach ARCH,$(DOCKER_ARCHS),$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)-linux-$(ARCH):$(DOCKER_IMAGE_TAG))
+	DOCKER_CLI_EXPERIMENTAL=enabled docker manifest push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)"

 .PHONY: promu
 promu: $(PROMU)
@@ -275,9 +265,3 @@ $(1)_precheck:
 		exit 1; \
 	fi
 endef
-
-govulncheck: install-govulncheck
-	govulncheck ./...
-
-install-govulncheck:
-	command -v govulncheck > /dev/null || go install golang.org/x/vuln/cmd/govulncheck@latest
--- a/vendor/github.com/prometheus/procfs/README.md
+++ b/vendor/github.com/prometheus/procfs/README.md
@@ -47,15 +47,15 @@ However, most of the API includes unit tests which can be run with `make test`.
 The procfs library includes a set of test fixtures which include many example files from
 the `/proc` and `/sys` filesystems.  These fixtures are included as a [ttar](https://github.com/ideaship/ttar) file
 which is extracted automatically during testing.  To add/update the test fixtures, first
-ensure the `testdata/fixtures` directory is up to date by removing the existing directory and then
-extracting the ttar file using `make testdata/fixtures/.unpacked` or just `make test`.
+ensure the `fixtures` directory is up to date by removing the existing directory and then
+extracting the ttar file using `make fixtures/.unpacked` or just `make test`.

 ```bash
-rm -rf testdata/fixtures
+rm -rf fixtures
 make test
 ```

-Next, make the required changes to the extracted files in the `testdata/fixtures` directory.  When
+Next, make the required changes to the extracted files in the `fixtures` directory.  When
 the changes are complete, run `make update_fixtures` to create a new `fixtures.ttar` file
 based on the updated `fixtures` directory.  And finally, verify the changes using
-`git diff testdata/fixtures.ttar`.
+`git diff fixtures.ttar`.
--- a/vendor/github.com/prometheus/procfs/arp.go
+++ b/vendor/github.com/prometheus/procfs/arp.go
@@ -23,9 +23,9 @@ import (

 // Learned from include/uapi/linux/if_arp.h.
 const (
-	// Completed entry (ha valid).
+	// completed entry (ha valid).
 	ATFComplete = 0x02
-	// Permanent entry.
+	// permanent entry.
 	ATFPermanent = 0x04
 	// Publish entry.
 	ATFPublish = 0x08
@@ -55,7 +55,7 @@ type ARPEntry struct {
 func (fs FS) GatherARPEntries() ([]ARPEntry, error) {
 	data, err := os.ReadFile(fs.proc.Path("net/arp"))
 	if err != nil {
-		return nil, fmt.Errorf("%w: error reading arp %s: %w", ErrFileRead, fs.proc.Path("net/arp"), err)
+		return nil, fmt.Errorf("error reading arp %q: %w", fs.proc.Path("net/arp"), err)
 	}

 	return parseARPEntries(data)
@@ -78,11 +78,11 @@ func parseARPEntries(data []byte) ([]ARPEntry, error) {
 		} else if width == expectedDataWidth {
 			entry, err := parseARPEntry(columns)
 			if err != nil {
-				return []ARPEntry{}, fmt.Errorf("%w: Failed to parse ARP entry: %v: %w", ErrFileParse, entry, err)
+				return []ARPEntry{}, fmt.Errorf("failed to parse ARP entry: %w", err)
 			}
 			entries = append(entries, entry)
 		} else {
-			return []ARPEntry{}, fmt.Errorf("%w: %d columns found, but expected %d: %w", ErrFileParse, width, expectedDataWidth, err)
+			return []ARPEntry{}, fmt.Errorf("%d columns were detected, but %d were expected", width, expectedDataWidth)
 		}

 	}
--- a/vendor/github.com/prometheus/procfs/buddyinfo.go
+++ b/vendor/github.com/prometheus/procfs/buddyinfo.go
@@ -55,18 +55,18 @@ func parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) {
 		parts := strings.Fields(line)

 		if len(parts) < 4 {
-			return nil, fmt.Errorf("%w: Invalid number of fields, found: %v", ErrFileParse, parts)
+			return nil, fmt.Errorf("invalid number of fields when parsing buddyinfo")
 		}

-		node := strings.TrimSuffix(parts[1], ",")
-		zone := strings.TrimSuffix(parts[3], ",")
+		node := strings.TrimRight(parts[1], ",")
+		zone := strings.TrimRight(parts[3], ",")
 		arraySize := len(parts[4:])

 		if bucketCount == -1 {
 			bucketCount = arraySize
 		} else {
 			if bucketCount != arraySize {
-				return nil, fmt.Errorf("%w: mismatch in number of buddyinfo buckets, previous count %d, new count %d", ErrFileParse, bucketCount, arraySize)
+				return nil, fmt.Errorf("mismatch in number of buddyinfo buckets, previous count %d, new count %d", bucketCount, arraySize)
 			}
 		}

@@ -74,7 +74,7 @@ func parseBuddyInfo(r io.Reader) ([]BuddyInfo, error) {
 		for i := 0; i < arraySize; i++ {
 			sizes[i], err = strconv.ParseFloat(parts[i+4], 64)
 			if err != nil {
-				return nil, fmt.Errorf("%w: Invalid valid in buddyinfo: %f: %w", ErrFileParse, sizes[i], err)
+				return nil, fmt.Errorf("invalid value in buddyinfo: %w", err)
 			}
 		}

--- a/vendor/github.com/prometheus/procfs/cpuinfo.go
+++ b/vendor/github.com/prometheus/procfs/cpuinfo.go
@@ -79,7 +79,7 @@ func parseCPUInfoX86(info []byte) ([]CPUInfo, error) {
 	// find the first "processor" line
 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: Cannot parse  line: %q", ErrFileParse, firstLine)
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	v, err := strconv.ParseUint(field[1], 0, 32)
@@ -192,10 +192,9 @@ func parseCPUInfoARM(info []byte) ([]CPUInfo, error) {
 	scanner := bufio.NewScanner(bytes.NewReader(info))

 	firstLine := firstNonEmptyLine(scanner)
-	match, err := regexp.MatchString("^[Pp]rocessor", firstLine)
+	match, _ := regexp.MatchString("^[Pp]rocessor", firstLine)
 	if !match || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: Cannot parse line: %q: %w", ErrFileParse, firstLine, err)
-
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	cpuinfo := []CPUInfo{}
@@ -259,7 +258,7 @@ func parseCPUInfoS390X(info []byte) ([]CPUInfo, error) {

 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "vendor_id") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: Cannot parse line: %q", ErrFileParse, firstLine)
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	cpuinfo := []CPUInfo{}
@@ -284,7 +283,7 @@ func parseCPUInfoS390X(info []byte) ([]CPUInfo, error) {
 		if strings.HasPrefix(line, "processor") {
 			match := cpuinfoS390XProcessorRegexp.FindStringSubmatch(line)
 			if len(match) < 2 {
-				return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine)
+				return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 			}
 			cpu := commonCPUInfo
 			v, err := strconv.ParseUint(match[1], 0, 32)
@@ -344,7 +343,7 @@ func parseCPUInfoMips(info []byte) ([]CPUInfo, error) {
 	// find the first "processor" line
 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine)
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	cpuinfo := []CPUInfo{}
@@ -386,7 +385,7 @@ func parseCPUInfoLoong(info []byte) ([]CPUInfo, error) {
 	// find the first "processor" line
 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine)
+		return nil, errors.New("invalid cpuinfo file: " + firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	cpuinfo := []CPUInfo{}
@@ -422,7 +421,7 @@ func parseCPUInfoPPC(info []byte) ([]CPUInfo, error) {

 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine)
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	v, err := strconv.ParseUint(field[1], 0, 32)
@@ -467,7 +466,7 @@ func parseCPUInfoRISCV(info []byte) ([]CPUInfo, error) {

 	firstLine := firstNonEmptyLine(scanner)
 	if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
-		return nil, fmt.Errorf("%w: %q", ErrFileParse, firstLine)
+		return nil, fmt.Errorf("invalid cpuinfo file: %q", firstLine)
 	}
 	field := strings.SplitN(firstLine, ": ", 2)
 	v, err := strconv.ParseUint(field[1], 0, 32)
--- a/vendor/github.com/prometheus/procfs/crypto.go
+++ b/vendor/github.com/prometheus/procfs/crypto.go
@@ -55,13 +55,12 @@ func (fs FS) Crypto() ([]Crypto, error) {
 	path := fs.proc.Path("crypto")
 	b, err := util.ReadFileNoStat(path)
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot read file %v: %w", ErrFileRead, b, err)
-
+		return nil, fmt.Errorf("error reading crypto %q: %w", path, err)
 	}

 	crypto, err := parseCrypto(bytes.NewReader(b))
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, crypto, err)
+		return nil, fmt.Errorf("error parsing crypto %q: %w", path, err)
 	}

 	return crypto, nil
@@ -84,7 +83,7 @@ func parseCrypto(r io.Reader) ([]Crypto, error) {

 		kv := strings.Split(text, ":")
 		if len(kv) != 2 {
-			return nil, fmt.Errorf("%w: Cannot parse line: %q", ErrFileParse, text)
+			return nil, fmt.Errorf("malformed crypto line: %q", text)
 		}

 		k := strings.TrimSpace(kv[0])
--- a/vendor/github.com/prometheus/procfs/fs.go
+++ b/vendor/github.com/prometheus/procfs/fs.go
@@ -20,18 +20,11 @@ import (
 // FS represents the pseudo-filesystem sys, which provides an interface to
 // kernel data structures.
 type FS struct {
-	proc   fs.FS
-	isReal bool
+	proc fs.FS
 }

-const (
-	// DefaultMountPoint is the common mount point of the proc filesystem.
-	DefaultMountPoint = fs.DefaultProcMountPoint
-
-	// SectorSize represents the size of a sector in bytes.
-	// It is specific to Linux block I/O operations.
-	SectorSize = 512
-)
+// DefaultMountPoint is the common mount point of the proc filesystem.
+const DefaultMountPoint = fs.DefaultProcMountPoint

 // NewDefaultFS returns a new proc FS mounted under the default proc mountPoint.
 // It will error if the mount point directory can't be read or is a file.
@@ -46,11 +39,5 @@ func NewFS(mountPoint string) (FS, error) {
 	if err != nil {
 		return FS{}, err
 	}
-
-	isReal, err := isRealProc(mountPoint)
-	if err != nil {
-		return FS{}, err
-	}
-
-	return FS{fs, isReal}, nil
+	return FS{fs}, nil
 }
--- a/vendor/github.com/prometheus/procfs/fs_statfs_notype.go
+++ b/vendor/github.com/prometheus/procfs/fs_statfs_notype.go
@@ -1,23 +0,0 @@
-// Copyright 2018 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.
-
-//go:build !freebsd && !linux
-// +build !freebsd,!linux
-
-package procfs
-
-// isRealProc returns true on architectures that don't have a Type argument
-// in their Statfs_t struct.
-func isRealProc(_ string) (bool, error) {
-	return true, nil
-}
--- a/vendor/github.com/prometheus/procfs/fs_statfs_type.go
+++ b/vendor/github.com/prometheus/procfs/fs_statfs_type.go
@@ -1,33 +0,0 @@
-// Copyright 2018 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.
-
-//go:build freebsd || linux
-// +build freebsd linux
-
-package procfs
-
-import (
-	"syscall"
-)
-
-// isRealProc determines whether supplied mountpoint is really a proc filesystem.
-func isRealProc(mountPoint string) (bool, error) {
-	stat := syscall.Statfs_t{}
-	err := syscall.Statfs(mountPoint, &stat)
-	if err != nil {
-		return false, err
-	}
-
-	// 0x9fa0 is PROC_SUPER_MAGIC: https://elixir.bootlin.com/linux/v6.1/source/include/uapi/linux/magic.h#L87
-	return stat.Type == 0x9fa0, nil
-}
--- a/vendor/github.com/prometheus/procfs/fscache.go
+++ b/vendor/github.com/prometheus/procfs/fscache.go
@@ -162,7 +162,7 @@ type Fscacheinfo struct {
 	ReleaseRequestsAgainstPagesStoredByTimeLockGranted uint64
 	// Number of release reqs ignored due to in-progress store
 	ReleaseRequestsIgnoredDueToInProgressStore uint64
-	// Number of page stores canceled due to release req
+	// Number of page stores cancelled due to release req
 	PageStoresCancelledByReleaseRequests uint64
 	VmscanWaiting                        uint64
 	// Number of times async ops added to pending queues
@@ -171,11 +171,11 @@ type Fscacheinfo struct {
 	OpsRunning uint64
 	// Number of times async ops queued for processing
 	OpsEnqueued uint64
-	// Number of async ops canceled
+	// Number of async ops cancelled
 	OpsCancelled uint64
 	// Number of async ops rejected due to object lookup/create failure
 	OpsRejected uint64
-	// Number of async ops initialized
+	// Number of async ops initialised
 	OpsInitialised uint64
 	// Number of async ops queued for deferred release
 	OpsDeferred uint64
@@ -236,7 +236,7 @@ func (fs FS) Fscacheinfo() (Fscacheinfo, error) {

 	m, err := parseFscacheinfo(bytes.NewReader(b))
 	if err != nil {
-		return Fscacheinfo{}, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, m, err)
+		return Fscacheinfo{}, fmt.Errorf("failed to parse Fscacheinfo: %w", err)
 	}

 	return *m, nil
@@ -245,7 +245,7 @@ func (fs FS) Fscacheinfo() (Fscacheinfo, error) {
 func setFSCacheFields(fields []string, setFields ...*uint64) error {
 	var err error
 	if len(fields) < len(setFields) {
-		return fmt.Errorf("%w: Expected %d, but got %d: %w", ErrFileParse, len(setFields), len(fields), err)
+		return fmt.Errorf("Insufficient number of fields, expected %v, got %v", len(setFields), len(fields))
 	}

 	for i := range setFields {
@@ -263,7 +263,7 @@ func parseFscacheinfo(r io.Reader) (*Fscacheinfo, error) {
 	for s.Scan() {
 		fields := strings.Fields(s.Text())
 		if len(fields) < 2 {
-			return nil, fmt.Errorf("%w: malformed Fscacheinfo line: %q", ErrFileParse, s.Text())
+			return nil, fmt.Errorf("malformed Fscacheinfo line: %q", s.Text())
 		}

 		switch fields[0] {
--- a/vendor/github.com/prometheus/procfs/internal/fs/fs.go
+++ b/vendor/github.com/prometheus/procfs/internal/fs/fs.go
@@ -28,9 +28,6 @@ const (

 	// DefaultConfigfsMountPoint is the common mount point of the configfs.
 	DefaultConfigfsMountPoint = "/sys/kernel/config"
-
-	// DefaultSelinuxMountPoint is the common mount point of the selinuxfs.
-	DefaultSelinuxMountPoint = "/sys/fs/selinux"
 )

 // FS represents a pseudo-filesystem, normally /proc or /sys, which provides an
--- a/vendor/github.com/prometheus/procfs/internal/util/parse.go
+++ b/vendor/github.com/prometheus/procfs/internal/util/parse.go
@@ -14,7 +14,6 @@
 package util

 import (
-	"errors"
 	"os"
 	"strconv"
 	"strings"
@@ -65,21 +64,6 @@ func ParsePInt64s(ss []string) ([]*int64, error) {
 	return us, nil
 }

-// Parses a uint64 from given hex in string.
-func ParseHexUint64s(ss []string) ([]*uint64, error) {
-	us := make([]*uint64, 0, len(ss))
-	for _, s := range ss {
-		u, err := strconv.ParseUint(s, 16, 64)
-		if err != nil {
-			return nil, err
-		}
-
-		us = append(us, &u)
-	}
-
-	return us, nil
-}
-
 // ReadUintFromFile reads a file and attempts to parse a uint64 from it.
 func ReadUintFromFile(path string) (uint64, error) {
 	data, err := os.ReadFile(path)
@@ -111,16 +95,3 @@ 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)
-}
--- a/vendor/github.com/prometheus/procfs/ipvs.go
+++ b/vendor/github.com/prometheus/procfs/ipvs.go
@@ -221,16 +221,15 @@ func parseIPPort(s string) (net.IP, uint16, error) {
 	case 46:
 		ip = net.ParseIP(s[1:40])
 		if ip == nil {
-			return nil, 0, fmt.Errorf("%w: Invalid IPv6 addr %s: %w", ErrFileParse, s[1:40], err)
+			return nil, 0, fmt.Errorf("invalid IPv6 address: %s", s[1:40])
 		}
 	default:
-		return nil, 0, fmt.Errorf("%w: Unexpected IP:Port %s: %w", ErrFileParse, s, err)
+		return nil, 0, fmt.Errorf("unexpected IP:Port: %s", s)
 	}

 	portString := s[len(s)-4:]
 	if len(portString) != 4 {
-		return nil, 0,
-			fmt.Errorf("%w: Unexpected port string format %s: %w", ErrFileParse, portString, err)
+		return nil, 0, fmt.Errorf("unexpected port string format: %s", portString)
 	}
 	port, err := strconv.ParseUint(portString, 16, 16)
 	if err != nil {
--- a/vendor/github.com/prometheus/procfs/loadavg.go
+++ b/vendor/github.com/prometheus/procfs/loadavg.go
@@ -44,14 +44,14 @@ func parseLoad(loadavgBytes []byte) (*LoadAvg, error) {
 	loads := make([]float64, 3)
 	parts := strings.Fields(string(loadavgBytes))
 	if len(parts) < 3 {
-		return nil, fmt.Errorf("%w: Malformed line %q", ErrFileParse, string(loadavgBytes))
+		return nil, fmt.Errorf("malformed loadavg line: too few fields in loadavg string: %q", string(loadavgBytes))
 	}

 	var err error
 	for i, load := range parts[0:3] {
 		loads[i], err = strconv.ParseFloat(load, 64)
 		if err != nil {
-			return nil, fmt.Errorf("%w: Cannot parse load: %f: %w", ErrFileParse, loads[i], err)
+			return nil, fmt.Errorf("could not parse load %q: %w", load, err)
 		}
 	}
 	return &LoadAvg{
--- a/vendor/github.com/prometheus/procfs/mdstat.go
+++ b/vendor/github.com/prometheus/procfs/mdstat.go
@@ -23,7 +23,7 @@ import (

 var (
 	statusLineRE         = regexp.MustCompile(`(\d+) blocks .*\[(\d+)/(\d+)\] \[([U_]+)\]`)
-	recoveryLineBlocksRE = regexp.MustCompile(`\((\d+/\d+)\)`)
+	recoveryLineBlocksRE = regexp.MustCompile(`\((\d+)/\d+\)`)
 	recoveryLinePctRE    = regexp.MustCompile(`= (.+)%`)
 	recoveryLineFinishRE = regexp.MustCompile(`finish=(.+)min`)
 	recoveryLineSpeedRE  = regexp.MustCompile(`speed=(.+)[A-Z]`)
@@ -50,8 +50,6 @@ type MDStat struct {
 	BlocksTotal int64
 	// Number of blocks on the device that are in sync.
 	BlocksSynced int64
-	// Number of blocks on the device that need to be synced.
-	BlocksToBeSynced int64
 	// progress percentage of current sync
 	BlocksSyncedPct float64
 	// estimated finishing time for current sync (in minutes)
@@ -72,7 +70,7 @@ func (fs FS) MDStat() ([]MDStat, error) {
 	}
 	mdstat, err := parseMDStat(data)
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse %v: %w", ErrFileParse, fs.proc.Path("mdstat"), err)
+		return nil, fmt.Errorf("error parsing mdstat %q: %w", fs.proc.Path("mdstat"), err)
 	}
 	return mdstat, nil
 }
@@ -92,13 +90,13 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {

 		deviceFields := strings.Fields(line)
 		if len(deviceFields) < 3 {
-			return nil, fmt.Errorf("%w: Expected 3+ lines, got %q", ErrFileParse, line)
+			return nil, fmt.Errorf("not enough fields in mdline (expected at least 3): %s", line)
 		}
 		mdName := deviceFields[0] // mdx
 		state := deviceFields[2]  // active or inactive

 		if len(lines) <= i+3 {
-			return nil, fmt.Errorf("%w: Too few lines for md device: %q", ErrFileParse, mdName)
+			return nil, fmt.Errorf("error parsing %q: too few lines for md device", mdName)
 		}

 		// Failed disks have the suffix (F) & Spare disks have the suffix (S).
@@ -107,7 +105,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {
 		active, total, down, size, err := evalStatusLine(lines[i], lines[i+1])

 		if err != nil {
-			return nil, fmt.Errorf("%w: Cannot parse md device lines: %v: %w", ErrFileParse, active, err)
+			return nil, fmt.Errorf("error parsing md device lines: %w", err)
 		}

 		syncLineIdx := i + 2
@@ -117,8 +115,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {

 		// If device is syncing at the moment, get the number of currently
 		// synced bytes, otherwise that number equals the size of the device.
-		blocksSynced := size
-		blocksToBeSynced := size
+		syncedBlocks := size
 		speed := float64(0)
 		finish := float64(0)
 		pct := float64(0)
@@ -139,11 +136,11 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {
 			// Handle case when resync=PENDING or resync=DELAYED.
 			if strings.Contains(lines[syncLineIdx], "PENDING") ||
 				strings.Contains(lines[syncLineIdx], "DELAYED") {
-				blocksSynced = 0
+				syncedBlocks = 0
 			} else {
-				blocksSynced, blocksToBeSynced, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx])
+				syncedBlocks, pct, finish, speed, err = evalRecoveryLine(lines[syncLineIdx])
 				if err != nil {
-					return nil, fmt.Errorf("%w: Cannot parse sync line in md device: %q: %w", ErrFileParse, mdName, err)
+					return nil, fmt.Errorf("error parsing sync line in md device %q: %w", mdName, err)
 				}
 			}
 		}
@@ -157,8 +154,7 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {
 			DisksSpare:             spare,
 			DisksTotal:             total,
 			BlocksTotal:            size,
-			BlocksSynced:           blocksSynced,
-			BlocksToBeSynced:       blocksToBeSynced,
+			BlocksSynced:           syncedBlocks,
 			BlocksSyncedPct:        pct,
 			BlocksSyncedFinishTime: finish,
 			BlocksSyncedSpeed:      speed,
@@ -172,13 +168,13 @@ func parseMDStat(mdStatData []byte) ([]MDStat, error) {
 func evalStatusLine(deviceLine, statusLine string) (active, total, down, size int64, err error) {
 	statusFields := strings.Fields(statusLine)
 	if len(statusFields) < 1 {
-		return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err)
+		return 0, 0, 0, 0, fmt.Errorf("unexpected statusLine %q", statusLine)
 	}

 	sizeStr := statusFields[0]
 	size, err = strconv.ParseInt(sizeStr, 10, 64)
 	if err != nil {
-		return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err)
+		return 0, 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
 	}

 	if strings.Contains(deviceLine, "raid0") || strings.Contains(deviceLine, "linear") {
@@ -193,71 +189,65 @@ func evalStatusLine(deviceLine, statusLine string) (active, total, down, size in

 	matches := statusLineRE.FindStringSubmatch(statusLine)
 	if len(matches) != 5 {
-		return 0, 0, 0, 0, fmt.Errorf("%w: Could not fild all substring matches %s: %w", ErrFileParse, statusLine, err)
+		return 0, 0, 0, 0, fmt.Errorf("couldn't find all the substring matches: %s", statusLine)
 	}

 	total, err = strconv.ParseInt(matches[2], 10, 64)
 	if err != nil {
-		return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected statusline %q: %w", ErrFileParse, statusLine, err)
+		return 0, 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
 	}

 	active, err = strconv.ParseInt(matches[3], 10, 64)
 	if err != nil {
-		return 0, 0, 0, 0, fmt.Errorf("%w: Unexpected active %d: %w", ErrFileParse, active, err)
+		return 0, 0, 0, 0, fmt.Errorf("unexpected statusLine %q: %w", statusLine, err)
 	}
 	down = int64(strings.Count(matches[4], "_"))

 	return active, total, down, size, nil
 }

-func evalRecoveryLine(recoveryLine string) (blocksSynced int64, blocksToBeSynced int64, pct float64, finish float64, speed float64, err error) {
+func evalRecoveryLine(recoveryLine string) (syncedBlocks int64, pct float64, finish float64, speed float64, err error) {
 	matches := recoveryLineBlocksRE.FindStringSubmatch(recoveryLine)
 	if len(matches) != 2 {
-		return 0, 0, 0, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine blocks %s: %w", ErrFileParse, recoveryLine, err)
+		return 0, 0, 0, 0, fmt.Errorf("unexpected recoveryLine: %s", recoveryLine)
 	}

-	blocks := strings.Split(matches[1], "/")
-	blocksSynced, err = strconv.ParseInt(blocks[0], 10, 64)
+	syncedBlocks, err = strconv.ParseInt(matches[1], 10, 64)
 	if err != nil {
-		return 0, 0, 0, 0, 0, fmt.Errorf("%w: Unable to parse recovery blocks synced %q: %w", ErrFileParse, matches[1], err)
-	}
-
-	blocksToBeSynced, err = strconv.ParseInt(blocks[1], 10, 64)
-	if err != nil {
-		return blocksSynced, 0, 0, 0, 0, fmt.Errorf("%w: Unable to parse recovery to be synced blocks %q: %w", ErrFileParse, matches[2], err)
+		return 0, 0, 0, 0, fmt.Errorf("error parsing int from recoveryLine %q: %w", recoveryLine, err)
 	}

 	// Get percentage complete
 	matches = recoveryLinePctRE.FindStringSubmatch(recoveryLine)
 	if len(matches) != 2 {
-		return blocksSynced, blocksToBeSynced, 0, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching percentage %s", ErrFileParse, recoveryLine)
+		return syncedBlocks, 0, 0, 0, fmt.Errorf("unexpected recoveryLine matching percentage: %s", recoveryLine)
 	}
 	pct, err = strconv.ParseFloat(strings.TrimSpace(matches[1]), 64)
 	if err != nil {
-		return blocksSynced, blocksToBeSynced, 0, 0, 0, fmt.Errorf("%w: Error parsing float from recoveryLine %q", ErrFileParse, recoveryLine)
+		return syncedBlocks, 0, 0, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
 	}

 	// Get time expected left to complete
 	matches = recoveryLineFinishRE.FindStringSubmatch(recoveryLine)
 	if len(matches) != 2 {
-		return blocksSynced, blocksToBeSynced, pct, 0, 0, fmt.Errorf("%w: Unexpected recoveryLine matching est. finish time: %s", ErrFileParse, recoveryLine)
+		return syncedBlocks, pct, 0, 0, fmt.Errorf("unexpected recoveryLine matching est. finish time: %s", recoveryLine)
 	}
 	finish, err = strconv.ParseFloat(matches[1], 64)
 	if err != nil {
-		return blocksSynced, blocksToBeSynced, pct, 0, 0, fmt.Errorf("%w: Unable to parse float from recoveryLine: %q", ErrFileParse, recoveryLine)
+		return syncedBlocks, pct, 0, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
 	}

 	// Get recovery speed
 	matches = recoveryLineSpeedRE.FindStringSubmatch(recoveryLine)
 	if len(matches) != 2 {
-		return blocksSynced, blocksToBeSynced, pct, finish, 0, fmt.Errorf("%w: Unexpected recoveryLine value: %s", ErrFileParse, recoveryLine)
+		return syncedBlocks, pct, finish, 0, fmt.Errorf("unexpected recoveryLine matching speed: %s", recoveryLine)
 	}
 	speed, err = strconv.ParseFloat(matches[1], 64)
 	if err != nil {
-		return blocksSynced, blocksToBeSynced, pct, finish, 0, fmt.Errorf("%w: Error parsing float from recoveryLine: %q: %w", ErrFileParse, recoveryLine, err)
+		return syncedBlocks, pct, finish, 0, fmt.Errorf("error parsing float from recoveryLine %q: %w", recoveryLine, err)
 	}

-	return blocksSynced, blocksToBeSynced, pct, finish, speed, nil
+	return syncedBlocks, pct, finish, speed, nil
 }

 func evalComponentDevices(deviceFields []string) []string {
--- a/vendor/github.com/prometheus/procfs/meminfo.go
+++ b/vendor/github.com/prometheus/procfs/meminfo.go
@@ -126,7 +126,6 @@ type Meminfo struct {
 	VmallocUsed *uint64
 	// largest contiguous block of vmalloc area which is free
 	VmallocChunk      *uint64
-	Percpu            *uint64
 	HardwareCorrupted *uint64
 	AnonHugePages     *uint64
 	ShmemHugePages    *uint64
@@ -141,55 +140,6 @@ type Meminfo struct {
 	DirectMap4k       *uint64
 	DirectMap2M       *uint64
 	DirectMap1G       *uint64
-
-	// The struct fields below are the byte-normalized counterparts to the
-	// existing struct fields. Values are normalized using the optional
-	// unit field in the meminfo line.
-	MemTotalBytes          *uint64
-	MemFreeBytes           *uint64
-	MemAvailableBytes      *uint64
-	BuffersBytes           *uint64
-	CachedBytes            *uint64
-	SwapCachedBytes        *uint64
-	ActiveBytes            *uint64
-	InactiveBytes          *uint64
-	ActiveAnonBytes        *uint64
-	InactiveAnonBytes      *uint64
-	ActiveFileBytes        *uint64
-	InactiveFileBytes      *uint64
-	UnevictableBytes       *uint64
-	MlockedBytes           *uint64
-	SwapTotalBytes         *uint64
-	SwapFreeBytes          *uint64
-	DirtyBytes             *uint64
-	WritebackBytes         *uint64
-	AnonPagesBytes         *uint64
-	MappedBytes            *uint64
-	ShmemBytes             *uint64
-	SlabBytes              *uint64
-	SReclaimableBytes      *uint64
-	SUnreclaimBytes        *uint64
-	KernelStackBytes       *uint64
-	PageTablesBytes        *uint64
-	NFSUnstableBytes       *uint64
-	BounceBytes            *uint64
-	WritebackTmpBytes      *uint64
-	CommitLimitBytes       *uint64
-	CommittedASBytes       *uint64
-	VmallocTotalBytes      *uint64
-	VmallocUsedBytes       *uint64
-	VmallocChunkBytes      *uint64
-	PercpuBytes            *uint64
-	HardwareCorruptedBytes *uint64
-	AnonHugePagesBytes     *uint64
-	ShmemHugePagesBytes    *uint64
-	ShmemPmdMappedBytes    *uint64
-	CmaTotalBytes          *uint64
-	CmaFreeBytes           *uint64
-	HugepagesizeBytes      *uint64
-	DirectMap4kBytes       *uint64
-	DirectMap2MBytes       *uint64
-	DirectMap1GBytes       *uint64
 }

 // Meminfo returns an information about current kernel/system memory statistics.
@@ -202,7 +152,7 @@ func (fs FS) Meminfo() (Meminfo, error) {

 	m, err := parseMemInfo(bytes.NewReader(b))
 	if err != nil {
-		return Meminfo{}, fmt.Errorf("%w: %w", ErrFileParse, err)
+		return Meminfo{}, fmt.Errorf("failed to parse meminfo: %w", err)
 	}

 	return *m, nil
@@ -212,176 +162,114 @@ func parseMemInfo(r io.Reader) (*Meminfo, error) {
 	var m Meminfo
 	s := bufio.NewScanner(r)
 	for s.Scan() {
+		// Each line has at least a name and value; we ignore the unit.
 		fields := strings.Fields(s.Text())
-		var val, valBytes uint64
+		if len(fields) < 2 {
+			return nil, fmt.Errorf("malformed meminfo line: %q", s.Text())
+		}

-		val, err := strconv.ParseUint(fields[1], 0, 64)
+		v, err := strconv.ParseUint(fields[1], 0, 64)
 		if err != nil {
 			return nil, err
 		}

-		switch len(fields) {
-		case 2:
-			// No unit present, use the parsed the value as bytes directly.
-			valBytes = val
-		case 3:
-			// Unit present in optional 3rd field, convert it to
-			// bytes. The only unit supported within the Linux
-			// kernel is `kB`.
-			if fields[2] != "kB" {
-				return nil, fmt.Errorf("%w: Unsupported unit in optional 3rd field %q", ErrFileParse, fields[2])
-			}
-
-			valBytes = 1024 * val
-
-		default:
-			return nil, fmt.Errorf("%w: Malformed line %q", ErrFileParse, s.Text())
-		}
-
 		switch fields[0] {
 		case "MemTotal:":
-			m.MemTotal = &val
-			m.MemTotalBytes = &valBytes
+			m.MemTotal = &v
 		case "MemFree:":
-			m.MemFree = &val
-			m.MemFreeBytes = &valBytes
+			m.MemFree = &v
 		case "MemAvailable:":
-			m.MemAvailable = &val
-			m.MemAvailableBytes = &valBytes
+			m.MemAvailable = &v
 		case "Buffers:":
-			m.Buffers = &val
-			m.BuffersBytes = &valBytes
+			m.Buffers = &v
 		case "Cached:":
-			m.Cached = &val
-			m.CachedBytes = &valBytes
+			m.Cached = &v
 		case "SwapCached:":
-			m.SwapCached = &val
-			m.SwapCachedBytes = &valBytes
+			m.SwapCached = &v
 		case "Active:":
-			m.Active = &val
-			m.ActiveBytes = &valBytes
+			m.Active = &v
 		case "Inactive:":
-			m.Inactive = &val
-			m.InactiveBytes = &valBytes
+			m.Inactive = &v
 		case "Active(anon):":
-			m.ActiveAnon = &val
-			m.ActiveAnonBytes = &valBytes
+			m.ActiveAnon = &v
 		case "Inactive(anon):":
-			m.InactiveAnon = &val
-			m.InactiveAnonBytes = &valBytes
+			m.InactiveAnon = &v
 		case "Active(file):":
-			m.ActiveFile = &val
-			m.ActiveFileBytes = &valBytes
+			m.ActiveFile = &v
 		case "Inactive(file):":
-			m.InactiveFile = &val
-			m.InactiveFileBytes = &valBytes
+			m.InactiveFile = &v
 		case "Unevictable:":
-			m.Unevictable = &val
-			m.UnevictableBytes = &valBytes
+			m.Unevictable = &v
 		case "Mlocked:":
-			m.Mlocked = &val
-			m.MlockedBytes = &valBytes
+			m.Mlocked = &v
 		case "SwapTotal:":
-			m.SwapTotal = &val
-			m.SwapTotalBytes = &valBytes
+			m.SwapTotal = &v
 		case "SwapFree:":
-			m.SwapFree = &val
-			m.SwapFreeBytes = &valBytes
+			m.SwapFree = &v
 		case "Dirty:":
-			m.Dirty = &val
-			m.DirtyBytes = &valBytes
+			m.Dirty = &v
 		case "Writeback:":
-			m.Writeback = &val
-			m.WritebackBytes = &valBytes
+			m.Writeback = &v
 		case "AnonPages:":
-			m.AnonPages = &val
-			m.AnonPagesBytes = &valBytes
+			m.AnonPages = &v
 		case "Mapped:":
-			m.Mapped = &val
-			m.MappedBytes = &valBytes
+			m.Mapped = &v
 		case "Shmem:":
-			m.Shmem = &val
-			m.ShmemBytes = &valBytes
+			m.Shmem = &v
 		case "Slab:":
-			m.Slab = &val
-			m.SlabBytes = &valBytes
+			m.Slab = &v
 		case "SReclaimable:":
-			m.SReclaimable = &val
-			m.SReclaimableBytes = &valBytes
+			m.SReclaimable = &v
 		case "SUnreclaim:":
-			m.SUnreclaim = &val
-			m.SUnreclaimBytes = &valBytes
+			m.SUnreclaim = &v
 		case "KernelStack:":
-			m.KernelStack = &val
-			m.KernelStackBytes = &valBytes
+			m.KernelStack = &v
 		case "PageTables:":
-			m.PageTables = &val
-			m.PageTablesBytes = &valBytes
+			m.PageTables = &v
 		case "NFS_Unstable:":
-			m.NFSUnstable = &val
-			m.NFSUnstableBytes = &valBytes
+			m.NFSUnstable = &v
 		case "Bounce:":
-			m.Bounce = &val
-			m.BounceBytes = &valBytes
+			m.Bounce = &v
 		case "WritebackTmp:":
-			m.WritebackTmp = &val
-			m.WritebackTmpBytes = &valBytes
+			m.WritebackTmp = &v
 		case "CommitLimit:":
-			m.CommitLimit = &val
-			m.CommitLimitBytes = &valBytes
+			m.CommitLimit = &v
 		case "Committed_AS:":
-			m.CommittedAS = &val
-			m.CommittedASBytes = &valBytes
+			m.CommittedAS = &v
 		case "VmallocTotal:":
-			m.VmallocTotal = &val
-			m.VmallocTotalBytes = &valBytes
+			m.VmallocTotal = &v
 		case "VmallocUsed:":
-			m.VmallocUsed = &val
-			m.VmallocUsedBytes = &valBytes
+			m.VmallocUsed = &v
 		case "VmallocChunk:":
-			m.VmallocChunk = &val
-			m.VmallocChunkBytes = &valBytes
-		case "Percpu:":
-			m.Percpu = &val
-			m.PercpuBytes = &valBytes
+			m.VmallocChunk = &v
 		case "HardwareCorrupted:":
-			m.HardwareCorrupted = &val
-			m.HardwareCorruptedBytes = &valBytes
+			m.HardwareCorrupted = &v
 		case "AnonHugePages:":
-			m.AnonHugePages = &val
-			m.AnonHugePagesBytes = &valBytes
+			m.AnonHugePages = &v
 		case "ShmemHugePages:":
-			m.ShmemHugePages = &val
-			m.ShmemHugePagesBytes = &valBytes
+			m.ShmemHugePages = &v
 		case "ShmemPmdMapped:":
-			m.ShmemPmdMapped = &val
-			m.ShmemPmdMappedBytes = &valBytes
+			m.ShmemPmdMapped = &v
 		case "CmaTotal:":
-			m.CmaTotal = &val
-			m.CmaTotalBytes = &valBytes
+			m.CmaTotal = &v
 		case "CmaFree:":
-			m.CmaFree = &val
-			m.CmaFreeBytes = &valBytes
+			m.CmaFree = &v
 		case "HugePages_Total:":
-			m.HugePagesTotal = &val
+			m.HugePagesTotal = &v
 		case "HugePages_Free:":
-			m.HugePagesFree = &val
+			m.HugePagesFree = &v
 		case "HugePages_Rsvd:":
-			m.HugePagesRsvd = &val
+			m.HugePagesRsvd = &v
 		case "HugePages_Surp:":
-			m.HugePagesSurp = &val
+			m.HugePagesSurp = &v
 		case "Hugepagesize:":
-			m.Hugepagesize = &val
-			m.HugepagesizeBytes = &valBytes
+			m.Hugepagesize = &v
 		case "DirectMap4k:":
-			m.DirectMap4k = &val
-			m.DirectMap4kBytes = &valBytes
+			m.DirectMap4k = &v
 		case "DirectMap2M:":
-			m.DirectMap2M = &val
-			m.DirectMap2MBytes = &valBytes
+			m.DirectMap2M = &v
 		case "DirectMap1G:":
-			m.DirectMap1G = &val
-			m.DirectMap1GBytes = &valBytes
+			m.DirectMap1G = &v
 		}
 	}

--- a/vendor/github.com/prometheus/procfs/mountinfo.go
+++ b/vendor/github.com/prometheus/procfs/mountinfo.go
@@ -78,11 +78,11 @@ func parseMountInfoString(mountString string) (*MountInfo, error) {
 	mountInfo := strings.Split(mountString, " ")
 	mountInfoLength := len(mountInfo)
 	if mountInfoLength < 10 {
-		return nil, fmt.Errorf("%w: Too few fields in mount string: %s", ErrFileParse, mountString)
+		return nil, fmt.Errorf("couldn't find enough fields in mount string: %s", mountString)
 	}

 	if mountInfo[mountInfoLength-4] != "-" {
-		return nil, fmt.Errorf("%w: couldn't find separator in expected field: %s", ErrFileParse, mountInfo[mountInfoLength-4])
+		return nil, fmt.Errorf("couldn't find separator in expected field: %s", mountInfo[mountInfoLength-4])
 	}

 	mount := &MountInfo{
@@ -98,18 +98,18 @@ func parseMountInfoString(mountString string) (*MountInfo, error) {

 	mount.MountID, err = strconv.Atoi(mountInfo[0])
 	if err != nil {
-		return nil, fmt.Errorf("%w: mount ID: %q", ErrFileParse, mount.MountID)
+		return nil, fmt.Errorf("failed to parse mount ID")
 	}
 	mount.ParentID, err = strconv.Atoi(mountInfo[1])
 	if err != nil {
-		return nil, fmt.Errorf("%w: parent ID: %q", ErrFileParse, mount.ParentID)
+		return nil, fmt.Errorf("failed to parse parent ID")
 	}
 	// Has optional fields, which is a space separated list of values.
 	// Example: shared:2 master:7
 	if mountInfo[6] != "" {
 		mount.OptionalFields, err = mountOptionsParseOptionalFields(mountInfo[6 : mountInfoLength-4])
 		if err != nil {
-			return nil, fmt.Errorf("%w: %w", ErrFileParse, err)
+			return nil, err
 		}
 	}
 	return mount, nil
--- a/vendor/github.com/prometheus/procfs/mountstats.go
+++ b/vendor/github.com/prometheus/procfs/mountstats.go
@@ -44,14 +44,6 @@ const (

 	fieldTransport11TCPLen = 13
 	fieldTransport11UDPLen = 10
-
-	// Kernel version >= 4.14 MaxLen
-	// See: https://elixir.bootlin.com/linux/v6.4.8/source/net/sunrpc/xprtrdma/xprt_rdma.h#L393
-	fieldTransport11RDMAMaxLen = 28
-
-	// Kernel version <= 4.2 MinLen
-	// See: https://elixir.bootlin.com/linux/v4.2.8/source/net/sunrpc/xprtrdma/xprt_rdma.h#L331
-	fieldTransport11RDMAMinLen = 20
 )

 // A Mount is a device mount parsed from /proc/[pid]/mountstats.
@@ -88,7 +80,7 @@ type MountStatsNFS struct {
 	// Statistics broken down by filesystem operation.
 	Operations []NFSOperationStats
 	// Statistics about the NFS RPC transport.
-	Transport []NFSTransportStats
+	Transport NFSTransportStats
 }

 // mountStats implements MountStats.
@@ -239,33 +231,6 @@ type NFSTransportStats struct {
 	// A running counter, incremented on each request as the current size of the
 	// pending queue.
 	CumulativePendingQueue uint64
-
-	// Stats below only available with stat version 1.1.
-	// Transport over RDMA
-
-	// accessed when sending a call
-	ReadChunkCount   uint64
-	WriteChunkCount  uint64
-	ReplyChunkCount  uint64
-	TotalRdmaRequest uint64
-
-	// rarely accessed error counters
-	PullupCopyCount      uint64
-	HardwayRegisterCount uint64
-	FailedMarshalCount   uint64
-	BadReplyCount        uint64
-	MrsRecovered         uint64
-	MrsOrphaned          uint64
-	MrsAllocated         uint64
-	EmptySendctxQ        uint64
-
-	// accessed when receiving a reply
-	TotalRdmaReply    uint64
-	FixupCopyCount    uint64
-	ReplyWaitsForSend uint64
-	LocalInvNeeded    uint64
-	NomsgCallCount    uint64
-	BcallCount        uint64
 }

 // parseMountStats parses a /proc/[pid]/mountstats file and returns a slice
@@ -299,7 +264,7 @@ func parseMountStats(r io.Reader) ([]*Mount, error) {
 		if len(ss) > deviceEntryLen {
 			// Only NFSv3 and v4 are supported for parsing statistics
 			if m.Type != nfs3Type && m.Type != nfs4Type {
-				return nil, fmt.Errorf("%w: Cannot parse MountStats for %q", ErrFileParse, m.Type)
+				return nil, fmt.Errorf("cannot parse MountStats for fstype %q", m.Type)
 			}

 			statVersion := strings.TrimPrefix(ss[8], statVersionPrefix)
@@ -323,7 +288,7 @@ func parseMountStats(r io.Reader) ([]*Mount, error) {
 //	device [device] mounted on [mount] with fstype [type]
 func parseMount(ss []string) (*Mount, error) {
 	if len(ss) < deviceEntryLen {
-		return nil, fmt.Errorf("%w: Invalid device %q", ErrFileParse, ss)
+		return nil, fmt.Errorf("invalid device entry: %v", ss)
 	}

 	// Check for specific words appearing at specific indices to ensure
@@ -341,7 +306,7 @@ func parseMount(ss []string) (*Mount, error) {

 	for _, f := range format {
 		if ss[f.i] != f.s {
-			return nil, fmt.Errorf("%w: Invalid device %q", ErrFileParse, ss)
+			return nil, fmt.Errorf("invalid device entry: %v", ss)
 		}
 	}

@@ -378,7 +343,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 		switch ss[0] {
 		case fieldOpts:
 			if len(ss) < 2 {
-				return nil, fmt.Errorf("%w: Incomplete information for NFS stats: %v", ErrFileParse, ss)
+				return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
 			}
 			if stats.Opts == nil {
 				stats.Opts = map[string]string{}
@@ -393,7 +358,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 			}
 		case fieldAge:
 			if len(ss) < 2 {
-				return nil, fmt.Errorf("%w: Incomplete information for NFS stats: %v", ErrFileParse, ss)
+				return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
 			}
 			// Age integer is in seconds
 			d, err := time.ParseDuration(ss[1] + "s")
@@ -404,7 +369,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 			stats.Age = d
 		case fieldBytes:
 			if len(ss) < 2 {
-				return nil, fmt.Errorf("%w: Incomplete information for NFS stats: %v", ErrFileParse, ss)
+				return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
 			}
 			bstats, err := parseNFSBytesStats(ss[1:])
 			if err != nil {
@@ -414,7 +379,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 			stats.Bytes = *bstats
 		case fieldEvents:
 			if len(ss) < 2 {
-				return nil, fmt.Errorf("%w: Incomplete information for NFS events: %v", ErrFileParse, ss)
+				return nil, fmt.Errorf("not enough information for NFS stats: %v", ss)
 			}
 			estats, err := parseNFSEventsStats(ss[1:])
 			if err != nil {
@@ -424,7 +389,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 			stats.Events = *estats
 		case fieldTransport:
 			if len(ss) < 3 {
-				return nil, fmt.Errorf("%w: Incomplete information for NFS transport stats: %v", ErrFileParse, ss)
+				return nil, fmt.Errorf("not enough information for NFS transport stats: %v", ss)
 			}

 			tstats, err := parseNFSTransportStats(ss[1:], statVersion)
@@ -432,7 +397,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 				return nil, err
 			}

-			stats.Transport = append(stats.Transport, *tstats)
+			stats.Transport = *tstats
 		}

 		// When encountering "per-operation statistics", we must break this
@@ -463,7 +428,7 @@ func parseMountStatsNFS(s *bufio.Scanner, statVersion string) (*MountStatsNFS, e
 // integer fields.
 func parseNFSBytesStats(ss []string) (*NFSBytesStats, error) {
 	if len(ss) != fieldBytesLen {
-		return nil, fmt.Errorf("%w: Invalid NFS bytes stats: %v", ErrFileParse, ss)
+		return nil, fmt.Errorf("invalid NFS bytes stats: %v", ss)
 	}

 	ns := make([]uint64, 0, fieldBytesLen)
@@ -492,7 +457,7 @@ func parseNFSBytesStats(ss []string) (*NFSBytesStats, error) {
 // integer fields.
 func parseNFSEventsStats(ss []string) (*NFSEventsStats, error) {
 	if len(ss) != fieldEventsLen {
-		return nil, fmt.Errorf("%w: invalid NFS events stats: %v", ErrFileParse, ss)
+		return nil, fmt.Errorf("invalid NFS events stats: %v", ss)
 	}

 	ns := make([]uint64, 0, fieldEventsLen)
@@ -556,7 +521,7 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
 		}

 		if len(ss) < minFields {
-			return nil, fmt.Errorf("%w: invalid NFS per-operations stats: %v", ErrFileParse, ss)
+			return nil, fmt.Errorf("invalid NFS per-operations stats: %v", ss)
 		}

 		// Skip string operation name for integers
@@ -569,6 +534,7 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {

 			ns = append(ns, n)
 		}
+
 		opStats := NFSOperationStats{
 			Operation:                           strings.TrimSuffix(ss[0], ":"),
 			Requests:                            ns[0],
@@ -606,10 +572,10 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats
 		} else if protocol == "udp" {
 			expectedLength = fieldTransport10UDPLen
 		} else {
-			return nil, fmt.Errorf("%w: Invalid NFS protocol \"%s\" in stats 1.0 statement: %v", ErrFileParse, protocol, ss)
+			return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.0 statement: %v", protocol, ss)
 		}
 		if len(ss) != expectedLength {
-			return nil, fmt.Errorf("%w: Invalid NFS transport stats 1.0 statement: %v", ErrFileParse, ss)
+			return nil, fmt.Errorf("invalid NFS transport stats 1.0 statement: %v", ss)
 		}
 	case statVersion11:
 		var expectedLength int
@@ -617,17 +583,14 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats
 			expectedLength = fieldTransport11TCPLen
 		} else if protocol == "udp" {
 			expectedLength = fieldTransport11UDPLen
-		} else if protocol == "rdma" {
-			expectedLength = fieldTransport11RDMAMinLen
 		} else {
-			return nil, fmt.Errorf("%w: invalid NFS protocol \"%s\" in stats 1.1 statement: %v", ErrFileParse, protocol, ss)
+			return nil, fmt.Errorf("invalid NFS protocol \"%s\" in stats 1.1 statement: %v", protocol, ss)
 		}
-		if (len(ss) != expectedLength && (protocol == "tcp" || protocol == "udp")) ||
-			(protocol == "rdma" && len(ss) < expectedLength) {
-			return nil, fmt.Errorf("%w: invalid NFS transport stats 1.1 statement: %v, protocol: %v", ErrFileParse, ss, protocol)
+		if len(ss) != expectedLength {
+			return nil, fmt.Errorf("invalid NFS transport stats 1.1 statement: %v", ss)
 		}
 	default:
-		return nil, fmt.Errorf("%w: Unrecognized NFS transport stats version: %q, protocol: %v", ErrFileParse, statVersion, protocol)
+		return nil, fmt.Errorf("unrecognized NFS transport stats version: %q", statVersion)
 	}

 	// Allocate enough for v1.1 stats since zero value for v1.1 stats will be okay
@@ -637,9 +600,7 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats
 	// Note: slice length must be set to length of v1.1 stats to avoid a panic when
 	// only v1.0 stats are present.
 	// See: https://github.com/prometheus/node_exporter/issues/571.
-	//
-	// Note: NFS Over RDMA slice length is fieldTransport11RDMAMaxLen
-	ns := make([]uint64, fieldTransport11RDMAMaxLen+3)
+	ns := make([]uint64, fieldTransport11TCPLen)
 	for i, s := range ss {
 		n, err := strconv.ParseUint(s, 10, 64)
 		if err != nil {
@@ -657,14 +618,9 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats
 	// we set them to 0 here.
 	if protocol == "udp" {
 		ns = append(ns[:2], append(make([]uint64, 3), ns[2:]...)...)
-	} else if protocol == "tcp" {
-		ns = append(ns[:fieldTransport11TCPLen], make([]uint64, fieldTransport11RDMAMaxLen-fieldTransport11TCPLen+3)...)
-	} else if protocol == "rdma" {
-		ns = append(ns[:fieldTransport10TCPLen], append(make([]uint64, 3), ns[fieldTransport10TCPLen:]...)...)
 	}

 	return &NFSTransportStats{
-		// NFS xprt over tcp or udp
 		Protocol:                 protocol,
 		Port:                     ns[0],
 		Bind:                     ns[1],
@@ -676,32 +632,8 @@ func parseNFSTransportStats(ss []string, statVersion string) (*NFSTransportStats
 		BadTransactionIDs:        ns[7],
 		CumulativeActiveRequests: ns[8],
 		CumulativeBacklog:        ns[9],
-
-		// NFS xprt over tcp or udp
-		// And statVersion 1.1
-		MaximumRPCSlotsUsed:    ns[10],
-		CumulativeSendingQueue: ns[11],
-		CumulativePendingQueue: ns[12],
-
-		// NFS xprt over rdma
-		// And stat Version 1.1
-		ReadChunkCount:       ns[13],
-		WriteChunkCount:      ns[14],
-		ReplyChunkCount:      ns[15],
-		TotalRdmaRequest:     ns[16],
-		PullupCopyCount:      ns[17],
-		HardwayRegisterCount: ns[18],
-		FailedMarshalCount:   ns[19],
-		BadReplyCount:        ns[20],
-		MrsRecovered:         ns[21],
-		MrsOrphaned:          ns[22],
-		MrsAllocated:         ns[23],
-		EmptySendctxQ:        ns[24],
-		TotalRdmaReply:       ns[25],
-		FixupCopyCount:       ns[26],
-		ReplyWaitsForSend:    ns[27],
-		LocalInvNeeded:       ns[28],
-		NomsgCallCount:       ns[29],
-		BcallCount:           ns[30],
+		MaximumRPCSlotsUsed:      ns[10],
+		CumulativeSendingQueue:   ns[11],
+		CumulativePendingQueue:   ns[12],
 	}, nil
 }
--- a/vendor/github.com/prometheus/procfs/net_conntrackstat.go
+++ b/vendor/github.com/prometheus/procfs/net_conntrackstat.go
@@ -18,6 +18,7 @@ import (
 	"bytes"
 	"fmt"
 	"io"
+	"strconv"
 	"strings"

 	"github.com/prometheus/procfs/internal/util"
@@ -27,13 +28,9 @@ import (
 // and contains netfilter conntrack statistics at one CPU core.
 type ConntrackStatEntry struct {
 	Entries       uint64
-	Searched      uint64
 	Found         uint64
-	New           uint64
 	Invalid       uint64
 	Ignore        uint64
-	Delete        uint64
-	DeleteList    uint64
 	Insert        uint64
 	InsertFailed  uint64
 	Drop          uint64
@@ -58,7 +55,7 @@ func readConntrackStat(path string) ([]ConntrackStatEntry, error) {

 	stat, err := parseConntrackStat(bytes.NewReader(b))
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, path, err)
+		return nil, fmt.Errorf("failed to read conntrack stats from %q: %w", path, err)
 	}

 	return stat, nil
@@ -84,35 +81,73 @@ func parseConntrackStat(r io.Reader) ([]ConntrackStatEntry, error) {

 // Parses a ConntrackStatEntry from given array of fields.
 func parseConntrackStatEntry(fields []string) (*ConntrackStatEntry, error) {
-	entries, err := util.ParseHexUint64s(fields)
+	if len(fields) != 17 {
+		return nil, fmt.Errorf("invalid conntrackstat entry, missing fields")
+	}
+	entry := &ConntrackStatEntry{}
+
+	entries, err := parseConntrackStatField(fields[0])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse entry: %d: %w", ErrFileParse, entries, err)
-	}
-	numEntries := len(entries)
-	if numEntries < 16 || numEntries > 17 {
-		return nil,
-			fmt.Errorf("%w: invalid conntrackstat entry, invalid number of fields: %d", ErrFileParse, numEntries)
+		return nil, err
 	}
+	entry.Entries = entries

-	stats := &ConntrackStatEntry{
-		Entries:      *entries[0],
-		Searched:     *entries[1],
-		Found:        *entries[2],
-		New:          *entries[3],
-		Invalid:      *entries[4],
-		Ignore:       *entries[5],
-		Delete:       *entries[6],
-		DeleteList:   *entries[7],
-		Insert:       *entries[8],
-		InsertFailed: *entries[9],
-		Drop:         *entries[10],
-		EarlyDrop:    *entries[11],
+	found, err := parseConntrackStatField(fields[2])
+	if err != nil {
+		return nil, err
 	}
+	entry.Found = found

-	// Ignore missing search_restart on Linux < 2.6.35.
-	if numEntries == 17 {
-		stats.SearchRestart = *entries[16]
+	invalid, err := parseConntrackStatField(fields[4])
+	if err != nil {
+		return nil, err
 	}
+	entry.Invalid = invalid

-	return stats, nil
+	ignore, err := parseConntrackStatField(fields[5])
+	if err != nil {
+		return nil, err
+	}
+	entry.Ignore = ignore
+
+	insert, err := parseConntrackStatField(fields[8])
+	if err != nil {
+		return nil, err
+	}
+	entry.Insert = insert
+
+	insertFailed, err := parseConntrackStatField(fields[9])
+	if err != nil {
+		return nil, err
+	}
+	entry.InsertFailed = insertFailed
+
+	drop, err := parseConntrackStatField(fields[10])
+	if err != nil {
+		return nil, err
+	}
+	entry.Drop = drop
+
+	earlyDrop, err := parseConntrackStatField(fields[11])
+	if err != nil {
+		return nil, err
+	}
+	entry.EarlyDrop = earlyDrop
+
+	searchRestart, err := parseConntrackStatField(fields[16])
+	if err != nil {
+		return nil, err
+	}
+	entry.SearchRestart = searchRestart
+
+	return entry, nil
+}
+
+// Parses a uint64 from given hex in string.
+func parseConntrackStatField(field string) (uint64, error) {
+	val, err := strconv.ParseUint(field, 16, 64)
+	if err != nil {
+		return 0, fmt.Errorf("couldn't parse %q field: %w", field, err)
+	}
+	return val, err
 }
--- a/vendor/github.com/prometheus/procfs/net_dev_snmp6.go
+++ b/vendor/github.com/prometheus/procfs/net_dev_snmp6.go
@@ -1,96 +0,0 @@
-// Copyright 2018 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 procfs
-
-import (
-	"bufio"
-	"errors"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-)
-
-// NetDevSNMP6 is parsed from files in /proc/net/dev_snmp6/ or /proc/<PID>/net/dev_snmp6/.
-// The outer map's keys are interface names and the inner map's keys are stat names.
-//
-// If you'd like a total across all interfaces, please use the Snmp6() method of the Proc type.
-type NetDevSNMP6 map[string]map[string]uint64
-
-// Returns kernel/system statistics read from interface files within the /proc/net/dev_snmp6/
-// directory.
-func (fs FS) NetDevSNMP6() (NetDevSNMP6, error) {
-	return newNetDevSNMP6(fs.proc.Path("net/dev_snmp6"))
-}
-
-// Returns kernel/system statistics read from interface files within the /proc/<PID>/net/dev_snmp6/
-// directory.
-func (p Proc) NetDevSNMP6() (NetDevSNMP6, error) {
-	return newNetDevSNMP6(p.path("net/dev_snmp6"))
-}
-
-// newNetDevSNMP6 creates a new NetDevSNMP6 from the contents of the given directory.
-func newNetDevSNMP6(dir string) (NetDevSNMP6, error) {
-	netDevSNMP6 := make(NetDevSNMP6)
-
-	// The net/dev_snmp6 folders contain one file per interface
-	ifaceFiles, err := os.ReadDir(dir)
-	if err != nil {
-		// On systems with IPv6 disabled, this directory won't exist.
-		// Do nothing.
-		if errors.Is(err, os.ErrNotExist) {
-			return netDevSNMP6, err
-		}
-		return netDevSNMP6, err
-	}
-
-	for _, iFaceFile := range ifaceFiles {
-		f, err := os.Open(dir + "/" + iFaceFile.Name())
-		if err != nil {
-			return netDevSNMP6, err
-		}
-		defer f.Close()
-
-		netDevSNMP6[iFaceFile.Name()], err = parseNetDevSNMP6Stats(f)
-		if err != nil {
-			return netDevSNMP6, err
-		}
-	}
-
-	return netDevSNMP6, nil
-}
-
-func parseNetDevSNMP6Stats(r io.Reader) (map[string]uint64, error) {
-	m := make(map[string]uint64)
-
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		stat := strings.Fields(scanner.Text())
-		if len(stat) < 2 {
-			continue
-		}
-		key, val := stat[0], stat[1]
-
-		// Expect stat name to contain "6" or be "ifIndex"
-		if strings.Contains(key, "6") || key == "ifIndex" {
-			v, err := strconv.ParseUint(val, 10, 64)
-			if err != nil {
-				return m, err
-			}
-
-			m[key] = v
-		}
-	}
-	return m, scanner.Err()
-}
--- a/vendor/github.com/prometheus/procfs/net_ip_socket.go
+++ b/vendor/github.com/prometheus/procfs/net_ip_socket.go
@@ -25,7 +25,7 @@ import (
 )

 const (
-	// Maximum size limit used by io.LimitReader while reading the content of the
+	// readLimit is used by io.LimitReader while reading the content of the
 	// /proc/net/udp{,6} files. The number of lines inside such a file is dynamic
 	// as each line represents a single used socket.
 	// In theory, the number of available sockets is 65535 (2^16 - 1) per IP.
@@ -50,13 +50,10 @@ type (
 		// UsedSockets shows the total number of parsed lines representing the
 		// number of used sockets.
 		UsedSockets uint64
-		// Drops shows the total number of dropped packets of all UDP sockets.
-		Drops *uint64
 	}

-	// A single line parser for fields from /proc/net/{t,u}dp{,6}.
-	// Fields which are not used by IPSocket are skipped.
-	// Drops is non-nil for udp{,6}, but nil for tcp{,6}.
+	// netIPSocketLine represents the fields parsed from a single line
+	// in /proc/net/{t,u}dp{,6}. Fields which are not used by IPSocket are skipped.
 	// For the proc file format details, see https://linux.die.net/man/5/proc.
 	netIPSocketLine struct {
 		Sl        uint64
@@ -69,7 +66,6 @@ type (
 		RxQueue   uint64
 		UID       uint64
 		Inode     uint64
-		Drops     *uint64
 	}
 )

@@ -81,14 +77,13 @@ func newNetIPSocket(file string) (NetIPSocket, error) {
 	defer f.Close()

 	var netIPSocket NetIPSocket
-	isUDP := strings.Contains(file, "udp")

 	lr := io.LimitReader(f, readLimit)
 	s := bufio.NewScanner(lr)
 	s.Scan() // skip first line with headers
 	for s.Scan() {
 		fields := strings.Fields(s.Text())
-		line, err := parseNetIPSocketLine(fields, isUDP)
+		line, err := parseNetIPSocketLine(fields)
 		if err != nil {
 			return nil, err
 		}
@@ -109,25 +104,19 @@ func newNetIPSocketSummary(file string) (*NetIPSocketSummary, error) {
 	defer f.Close()

 	var netIPSocketSummary NetIPSocketSummary
-	var udpPacketDrops uint64
-	isUDP := strings.Contains(file, "udp")

 	lr := io.LimitReader(f, readLimit)
 	s := bufio.NewScanner(lr)
 	s.Scan() // skip first line with headers
 	for s.Scan() {
 		fields := strings.Fields(s.Text())
-		line, err := parseNetIPSocketLine(fields, isUDP)
+		line, err := parseNetIPSocketLine(fields)
 		if err != nil {
 			return nil, err
 		}
 		netIPSocketSummary.TxQueueLength += line.TxQueue
 		netIPSocketSummary.RxQueueLength += line.RxQueue
 		netIPSocketSummary.UsedSockets++
-		if isUDP {
-			udpPacketDrops += *line.Drops
-			netIPSocketSummary.Drops = &udpPacketDrops
-		}
 	}
 	if err := s.Err(); err != nil {
 		return nil, err
@@ -141,7 +130,7 @@ func parseIP(hexIP string) (net.IP, error) {
 	var byteIP []byte
 	byteIP, err := hex.DecodeString(hexIP)
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse socket field in %q: %w", ErrFileParse, hexIP, err)
+		return nil, fmt.Errorf("cannot parse address field in socket line %q", hexIP)
 	}
 	switch len(byteIP) {
 	case 4:
@@ -155,17 +144,16 @@ func parseIP(hexIP string) (net.IP, error) {
 		}
 		return i, nil
 	default:
-		return nil, fmt.Errorf("%w: Unable to parse IP %s: %v", ErrFileParse, hexIP, nil)
+		return nil, fmt.Errorf("Unable to parse IP %s", hexIP)
 	}
 }

 // parseNetIPSocketLine parses a single line, represented by a list of fields.
-func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error) {
+func parseNetIPSocketLine(fields []string) (*netIPSocketLine, error) {
 	line := &netIPSocketLine{}
 	if len(fields) < 10 {
 		return nil, fmt.Errorf(
-			"%w: Less than 10 columns found %q",
-			ErrFileParse,
+			"cannot parse net socket line as it has less then 10 columns %q",
 			strings.Join(fields, " "),
 		)
 	}
@@ -174,74 +162,64 @@ func parseNetIPSocketLine(fields []string, isUDP bool) (*netIPSocketLine, error)
 	// sl
 	s := strings.Split(fields[0], ":")
 	if len(s) != 2 {
-		return nil, fmt.Errorf("%w: Unable to parse sl field in line %q", ErrFileParse, fields[0])
+		return nil, fmt.Errorf("cannot parse sl field in socket line %q", fields[0])
 	}

 	if line.Sl, err = strconv.ParseUint(s[0], 0, 64); err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse sl field in %q: %w", ErrFileParse, line.Sl, err)
+		return nil, fmt.Errorf("cannot parse sl value in socket line: %w", err)
 	}
 	// local_address
 	l := strings.Split(fields[1], ":")
 	if len(l) != 2 {
-		return nil, fmt.Errorf("%w: Unable to parse local_address field in %q", ErrFileParse, fields[1])
+		return nil, fmt.Errorf("cannot parse local_address field in socket line %q", fields[1])
 	}
 	if line.LocalAddr, err = parseIP(l[0]); err != nil {
 		return nil, err
 	}
 	if line.LocalPort, err = strconv.ParseUint(l[1], 16, 64); err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse local_address port value line %q: %w", ErrFileParse, line.LocalPort, err)
+		return nil, fmt.Errorf("cannot parse local_address port value in socket line: %w", err)
 	}

 	// remote_address
 	r := strings.Split(fields[2], ":")
 	if len(r) != 2 {
-		return nil, fmt.Errorf("%w: Unable to parse rem_address field in %q", ErrFileParse, fields[1])
+		return nil, fmt.Errorf("cannot parse rem_address field in socket line %q", fields[1])
 	}
 	if line.RemAddr, err = parseIP(r[0]); err != nil {
 		return nil, err
 	}
 	if line.RemPort, err = strconv.ParseUint(r[1], 16, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse rem_address port value in %q: %w", ErrFileParse, line.RemPort, err)
+		return nil, fmt.Errorf("cannot parse rem_address port value in socket line: %w", err)
 	}

 	// st
 	if line.St, err = strconv.ParseUint(fields[3], 16, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse st value in %q: %w", ErrFileParse, line.St, err)
+		return nil, fmt.Errorf("cannot parse st value in socket line: %w", err)
 	}

 	// tx_queue and rx_queue
 	q := strings.Split(fields[4], ":")
 	if len(q) != 2 {
 		return nil, fmt.Errorf(
-			"%w: Missing colon for tx/rx queues in socket line %q",
-			ErrFileParse,
+			"cannot parse tx/rx queues in socket line as it has a missing colon %q",
 			fields[4],
 		)
 	}
 	if line.TxQueue, err = strconv.ParseUint(q[0], 16, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse tx_queue value in %q: %w", ErrFileParse, line.TxQueue, err)
+		return nil, fmt.Errorf("cannot parse tx_queue value in socket line: %w", err)
 	}
 	if line.RxQueue, err = strconv.ParseUint(q[1], 16, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse trx_queue value in %q: %w", ErrFileParse, line.RxQueue, err)
+		return nil, fmt.Errorf("cannot parse rx_queue value in socket line: %w", err)
 	}

 	// uid
 	if line.UID, err = strconv.ParseUint(fields[7], 0, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse UID value in %q: %w", ErrFileParse, line.UID, err)
+		return nil, fmt.Errorf("cannot parse uid value in socket line: %w", err)
 	}

 	// inode
 	if line.Inode, err = strconv.ParseUint(fields[9], 0, 64); err != nil {
-		return nil, fmt.Errorf("%w: Cannot parse inode value in %q: %w", ErrFileParse, line.Inode, err)
-	}
-
-	// drops
-	if isUDP {
-		drops, err := strconv.ParseUint(fields[12], 0, 64)
-		if err != nil {
-			return nil, fmt.Errorf("%w: Cannot parse drops value in %q: %w", ErrFileParse, drops, err)
-		}
-		line.Drops = &drops
+		return nil, fmt.Errorf("cannot parse inode value in socket line: %w", err)
 	}

 	return line, nil
--- a/vendor/github.com/prometheus/procfs/net_protocols.go
+++ b/vendor/github.com/prometheus/procfs/net_protocols.go
@@ -131,7 +131,7 @@ func (ps NetProtocolStats) parseLine(rawLine string) (*NetProtocolStatLine, erro
 	} else if fields[6] == disabled {
 		line.Slab = false
 	} else {
-		return nil, fmt.Errorf("%w: capability for protocol: %s", ErrFileParse, line.Name)
+		return nil, fmt.Errorf("unable to parse capability for protocol: %s", line.Name)
 	}
 	line.ModuleName = fields[7]

@@ -173,7 +173,7 @@ func (pc *NetProtocolCapabilities) parseCapabilities(capabilities []string) erro
 		} else if capabilities[i] == "n" {
 			*capabilityFields[i] = false
 		} else {
-			return fmt.Errorf("%w: capability block for protocol: position %d", ErrFileParse, i)
+			return fmt.Errorf("unable to parse capability block for protocol: position %d", i)
 		}
 	}
 	return nil
--- a/vendor/github.com/prometheus/procfs/net_route.go
+++ b/vendor/github.com/prometheus/procfs/net_route.go
@@ -1,143 +0,0 @@
-// Copyright 2023 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 procfs
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-
-	"github.com/prometheus/procfs/internal/util"
-)
-
-const (
-	blackholeRepresentation string = "*"
-	blackholeIfaceName      string = "blackhole"
-	routeLineColumns        int    = 11
-)
-
-// A NetRouteLine represents one line from net/route.
-type NetRouteLine struct {
-	Iface       string
-	Destination uint32
-	Gateway     uint32
-	Flags       uint32
-	RefCnt      uint32
-	Use         uint32
-	Metric      uint32
-	Mask        uint32
-	MTU         uint32
-	Window      uint32
-	IRTT        uint32
-}
-
-func (fs FS) NetRoute() ([]NetRouteLine, error) {
-	return readNetRoute(fs.proc.Path("net", "route"))
-}
-
-func readNetRoute(path string) ([]NetRouteLine, error) {
-	b, err := util.ReadFileNoStat(path)
-	if err != nil {
-		return nil, err
-	}
-
-	routelines, err := parseNetRoute(bytes.NewReader(b))
-	if err != nil {
-		return nil, fmt.Errorf("failed to read net route from %s: %w", path, err)
-	}
-	return routelines, nil
-}
-
-func parseNetRoute(r io.Reader) ([]NetRouteLine, error) {
-	var routelines []NetRouteLine
-
-	scanner := bufio.NewScanner(r)
-	scanner.Scan()
-	for scanner.Scan() {
-		fields := strings.Fields(scanner.Text())
-		routeline, err := parseNetRouteLine(fields)
-		if err != nil {
-			return nil, err
-		}
-		routelines = append(routelines, *routeline)
-	}
-	return routelines, nil
-}
-
-func parseNetRouteLine(fields []string) (*NetRouteLine, error) {
-	if len(fields) != routeLineColumns {
-		return nil, fmt.Errorf("invalid routeline, num of digits: %d", len(fields))
-	}
-	iface := fields[0]
-	if iface == blackholeRepresentation {
-		iface = blackholeIfaceName
-	}
-	destination, err := strconv.ParseUint(fields[1], 16, 32)
-	if err != nil {
-		return nil, err
-	}
-	gateway, err := strconv.ParseUint(fields[2], 16, 32)
-	if err != nil {
-		return nil, err
-	}
-	flags, err := strconv.ParseUint(fields[3], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	refcnt, err := strconv.ParseUint(fields[4], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	use, err := strconv.ParseUint(fields[5], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	metric, err := strconv.ParseUint(fields[6], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	mask, err := strconv.ParseUint(fields[7], 16, 32)
-	if err != nil {
-		return nil, err
-	}
-	mtu, err := strconv.ParseUint(fields[8], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	window, err := strconv.ParseUint(fields[9], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	irtt, err := strconv.ParseUint(fields[10], 10, 32)
-	if err != nil {
-		return nil, err
-	}
-	routeline := &NetRouteLine{
-		Iface:       iface,
-		Destination: uint32(destination),
-		Gateway:     uint32(gateway),
-		Flags:       uint32(flags),
-		RefCnt:      uint32(refcnt),
-		Use:         uint32(use),
-		Metric:      uint32(metric),
-		Mask:        uint32(mask),
-		MTU:         uint32(mtu),
-		Window:      uint32(window),
-		IRTT:        uint32(irtt),
-	}
-	return routeline, nil
-}
--- a/vendor/github.com/prometheus/procfs/net_sockstat.go
+++ b/vendor/github.com/prometheus/procfs/net_sockstat.go
@@ -16,6 +16,7 @@ package procfs
 import (
 	"bufio"
 	"bytes"
+	"errors"
 	"fmt"
 	"io"
 	"strings"
@@ -69,7 +70,7 @@ func readSockstat(name string) (*NetSockstat, error) {

 	stat, err := parseSockstat(bytes.NewReader(b))
 	if err != nil {
-		return nil, fmt.Errorf("%w: sockstats from %q: %w", ErrFileRead, name, err)
+		return nil, fmt.Errorf("failed to read sockstats from %q: %w", name, err)
 	}

 	return stat, nil
@@ -83,13 +84,13 @@ func parseSockstat(r io.Reader) (*NetSockstat, error) {
 		// Expect a minimum of a protocol and one key/value pair.
 		fields := strings.Split(s.Text(), " ")
 		if len(fields) < 3 {
-			return nil, fmt.Errorf("%w: Malformed sockstat line: %q", ErrFileParse, s.Text())
+			return nil, fmt.Errorf("malformed sockstat line: %q", s.Text())
 		}

 		// The remaining fields are key/value pairs.
 		kvs, err := parseSockstatKVs(fields[1:])
 		if err != nil {
-			return nil, fmt.Errorf("%w: sockstat key/value pairs from %q: %w", ErrFileParse, s.Text(), err)
+			return nil, fmt.Errorf("error parsing sockstat key/value pairs from %q: %w", s.Text(), err)
 		}

 		// The first field is the protocol. We must trim its colon suffix.
@@ -118,7 +119,7 @@ func parseSockstat(r io.Reader) (*NetSockstat, error) {
 // parseSockstatKVs parses a string slice into a map of key/value pairs.
 func parseSockstatKVs(kvs []string) (map[string]int, error) {
 	if len(kvs)%2 != 0 {
-		return nil, fmt.Errorf("%w:: Odd number of fields in key/value pairs %q", ErrFileParse, kvs)
+		return nil, errors.New("odd number of fields in key/value pairs")
 	}

 	// Iterate two values at a time to gather key/value pairs.
--- a/vendor/github.com/prometheus/procfs/net_softnet.go
+++ b/vendor/github.com/prometheus/procfs/net_softnet.go
@@ -64,7 +64,7 @@ func (fs FS) NetSoftnetStat() ([]SoftnetStat, error) {

 	entries, err := parseSoftnet(bytes.NewReader(b))
 	if err != nil {
-		return nil, fmt.Errorf("%w: /proc/net/softnet_stat: %w", ErrFileParse, err)
+		return nil, fmt.Errorf("failed to parse /proc/net/softnet_stat: %w", err)
 	}

 	return entries, nil
@@ -76,14 +76,13 @@ func parseSoftnet(r io.Reader) ([]SoftnetStat, error) {
 	s := bufio.NewScanner(r)

 	var stats []SoftnetStat
-	cpuIndex := 0
 	for s.Scan() {
 		columns := strings.Fields(s.Text())
 		width := len(columns)
 		softnetStat := SoftnetStat{}

 		if width < minColumns {
-			return nil, fmt.Errorf("%w: detected %d columns, but expected at least %d", ErrFileParse, width, minColumns)
+			return nil, fmt.Errorf("%d columns were detected, but at least %d were expected", width, minColumns)
 		}

 		// Linux 2.6.23 https://elixir.bootlin.com/linux/v2.6.23/source/net/core/dev.c#L2347
@@ -128,13 +127,9 @@ func parseSoftnet(r io.Reader) ([]SoftnetStat, error) {

 			softnetStat.SoftnetBacklogLen = us[0]
 			softnetStat.Index = us[1]
-		} else {
-			// For older kernels, create the Index based on the scan line number.
-			softnetStat.Index = uint32(cpuIndex)
 		}
 		softnetStat.Width = width
 		stats = append(stats, softnetStat)
-		cpuIndex++
 	}

 	return stats, nil
--- a/vendor/github.com/prometheus/procfs/net_tcp.go
+++ b/vendor/github.com/prometheus/procfs/net_tcp.go
@@ -25,28 +25,24 @@ type (

 // NetTCP returns the IPv4 kernel/networking statistics for TCP datagrams
 // read from /proc/net/tcp.
-// Deprecated: Use github.com/mdlayher/netlink#Conn (with syscall.AF_INET) instead.
 func (fs FS) NetTCP() (NetTCP, error) {
 	return newNetTCP(fs.proc.Path("net/tcp"))
 }

 // NetTCP6 returns the IPv6 kernel/networking statistics for TCP datagrams
 // read from /proc/net/tcp6.
-// Deprecated: Use github.com/mdlayher/netlink#Conn (with syscall.AF_INET6) instead.
 func (fs FS) NetTCP6() (NetTCP, error) {
 	return newNetTCP(fs.proc.Path("net/tcp6"))
 }

 // NetTCPSummary returns already computed statistics like the total queue lengths
 // for TCP datagrams read from /proc/net/tcp.
-// Deprecated: Use github.com/mdlayher/netlink#Conn (with syscall.AF_INET) instead.
 func (fs FS) NetTCPSummary() (*NetTCPSummary, error) {
 	return newNetTCPSummary(fs.proc.Path("net/tcp"))
 }

 // NetTCP6Summary returns already computed statistics like the total queue lengths
 // for TCP datagrams read from /proc/net/tcp6.
-// Deprecated: Use github.com/mdlayher/netlink#Conn (with syscall.AF_INET6) instead.
 func (fs FS) NetTCP6Summary() (*NetTCPSummary, error) {
 	return newNetTCPSummary(fs.proc.Path("net/tcp6"))
 }
--- a/vendor/github.com/prometheus/procfs/net_tls_stat.go
+++ b/vendor/github.com/prometheus/procfs/net_tls_stat.go
@@ -1,119 +0,0 @@
-// Copyright 2023 Prometheus Team
-// 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 procfs
-
-import (
-	"bufio"
-	"fmt"
-	"os"
-	"strconv"
-	"strings"
-)
-
-// TLSStat struct represents data in /proc/net/tls_stat.
-// See https://docs.kernel.org/networking/tls.html#statistics
-type TLSStat struct {
-	// number of TX sessions currently installed where host handles cryptography
-	TLSCurrTxSw int
-	// number of RX sessions currently installed where host handles cryptography
-	TLSCurrRxSw int
-	// number of TX sessions currently installed where NIC handles cryptography
-	TLSCurrTxDevice int
-	// number of RX sessions currently installed where NIC handles cryptography
-	TLSCurrRxDevice int
-	//number of TX sessions opened with host cryptography
-	TLSTxSw int
-	//number of RX sessions opened with host cryptography
-	TLSRxSw int
-	// number of TX sessions opened with NIC cryptography
-	TLSTxDevice int
-	// number of RX sessions opened with NIC cryptography
-	TLSRxDevice int
-	// record decryption failed (e.g. due to incorrect authentication tag)
-	TLSDecryptError int
-	//  number of RX resyncs sent to NICs handling cryptography
-	TLSRxDeviceResync int
-	// number of RX records which had to be re-decrypted due to TLS_RX_EXPECT_NO_PAD mis-prediction. Note that this counter will also increment for non-data records.
-	TLSDecryptRetry int
-	// number of data RX records which had to be re-decrypted due to TLS_RX_EXPECT_NO_PAD mis-prediction.
-	TLSRxNoPadViolation int
-}
-
-// NewTLSStat reads the tls_stat statistics.
-func NewTLSStat() (TLSStat, error) {
-	fs, err := NewFS(DefaultMountPoint)
-	if err != nil {
-		return TLSStat{}, err
-	}
-
-	return fs.NewTLSStat()
-}
-
-// NewTLSStat reads the tls_stat statistics.
-func (fs FS) NewTLSStat() (TLSStat, error) {
-	file, err := os.Open(fs.proc.Path("net/tls_stat"))
-	if err != nil {
-		return TLSStat{}, err
-	}
-	defer file.Close()
-
-	var (
-		tlsstat = TLSStat{}
-		s       = bufio.NewScanner(file)
-	)
-
-	for s.Scan() {
-		fields := strings.Fields(s.Text())
-
-		if len(fields) != 2 {
-			return TLSStat{}, fmt.Errorf("%w: %q line %q", ErrFileParse, file.Name(), s.Text())
-		}
-
-		name := fields[0]
-		value, err := strconv.Atoi(fields[1])
-		if err != nil {
-			return TLSStat{}, err
-		}
-
-		switch name {
-		case "TlsCurrTxSw":
-			tlsstat.TLSCurrTxSw = value
-		case "TlsCurrRxSw":
-			tlsstat.TLSCurrRxSw = value
-		case "TlsCurrTxDevice":
-			tlsstat.TLSCurrTxDevice = value
-		case "TlsCurrRxDevice":
-			tlsstat.TLSCurrRxDevice = value
-		case "TlsTxSw":
-			tlsstat.TLSTxSw = value
-		case "TlsRxSw":
-			tlsstat.TLSRxSw = value
-		case "TlsTxDevice":
-			tlsstat.TLSTxDevice = value
-		case "TlsRxDevice":
-			tlsstat.TLSRxDevice = value
-		case "TlsDecryptError":
-			tlsstat.TLSDecryptError = value
-		case "TlsRxDeviceResync":
-			tlsstat.TLSRxDeviceResync = value
-		case "TlsDecryptRetry":
-			tlsstat.TLSDecryptRetry = value
-		case "TlsRxNoPadViolation":
-			tlsstat.TLSRxNoPadViolation = value
-		}
-
-	}
-
-	return tlsstat, s.Err()
-}
--- a/vendor/github.com/prometheus/procfs/net_unix.go
+++ b/vendor/github.com/prometheus/procfs/net_unix.go
@@ -108,25 +108,25 @@ func parseNetUNIX(r io.Reader) (*NetUNIX, error) {
 		line := s.Text()
 		item, err := nu.parseLine(line, hasInode, minFields)
 		if err != nil {
-			return nil, fmt.Errorf("%w: /proc/net/unix encountered data %q: %w", ErrFileParse, line, err)
+			return nil, fmt.Errorf("failed to parse /proc/net/unix data %q: %w", line, err)
 		}

 		nu.Rows = append(nu.Rows, item)
 	}

 	if err := s.Err(); err != nil {
-		return nil, fmt.Errorf("%w: /proc/net/unix encountered data: %w", ErrFileParse, err)
+		return nil, fmt.Errorf("failed to scan /proc/net/unix data: %w", err)
 	}

 	return &nu, nil
 }

-func (u *NetUNIX) parseLine(line string, hasInode bool, minFields int) (*NetUNIXLine, error) {
+func (u *NetUNIX) parseLine(line string, hasInode bool, min int) (*NetUNIXLine, error) {
 	fields := strings.Fields(line)

 	l := len(fields)
-	if l < minFields {
-		return nil, fmt.Errorf("%w: expected at least %d fields but got %d", ErrFileParse, minFields, l)
+	if l < min {
+		return nil, fmt.Errorf("expected at least %d fields but got %d", min, l)
 	}

 	// Field offsets are as follows:
@@ -136,29 +136,29 @@ func (u *NetUNIX) parseLine(line string, hasInode bool, minFields int) (*NetUNIX

 	users, err := u.parseUsers(fields[1])
 	if err != nil {
-		return nil, fmt.Errorf("%w: ref count %q: %w", ErrFileParse, fields[1], err)
+		return nil, fmt.Errorf("failed to parse ref count %q: %w", fields[1], err)
 	}

 	flags, err := u.parseFlags(fields[3])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse flags %q: %w", ErrFileParse, fields[3], err)
+		return nil, fmt.Errorf("failed to parse flags %q: %w", fields[3], err)
 	}

 	typ, err := u.parseType(fields[4])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Failed to parse type %q: %w", ErrFileParse, fields[4], err)
+		return nil, fmt.Errorf("failed to parse type %q: %w", fields[4], err)
 	}

 	state, err := u.parseState(fields[5])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Failed to parse state %q: %w", ErrFileParse, fields[5], err)
+		return nil, fmt.Errorf("failed to parse state %q: %w", fields[5], err)
 	}

 	var inode uint64
 	if hasInode {
 		inode, err = u.parseInode(fields[6])
 		if err != nil {
-			return nil, fmt.Errorf("%w failed to parse inode %q: %w", ErrFileParse, fields[6], err)
+			return nil, fmt.Errorf("failed to parse inode %q: %w", fields[6], err)
 		}
 	}

@@ -172,7 +172,7 @@ func (u *NetUNIX) parseLine(line string, hasInode bool, minFields int) (*NetUNIX
 	}

 	// Path field is optional.
-	if l > minFields {
+	if l > min {
 		// Path occurs at either index 6 or 7 depending on whether inode is
 		// already present.
 		pathIdx := 7
--- a/vendor/github.com/prometheus/procfs/net_wireless.go
+++ b/vendor/github.com/prometheus/procfs/net_wireless.go
@@ -1,182 +0,0 @@
-// Copyright 2023 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 procfs
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"strconv"
-	"strings"
-
-	"github.com/prometheus/procfs/internal/util"
-)
-
-// Wireless models the content of /proc/net/wireless.
-type Wireless struct {
-	Name string
-
-	// Status is the current 4-digit hex value status of the interface.
-	Status uint64
-
-	// QualityLink is the link quality.
-	QualityLink int
-
-	// QualityLevel is the signal gain (dBm).
-	QualityLevel int
-
-	// QualityNoise is the signal noise baseline (dBm).
-	QualityNoise int
-
-	// DiscardedNwid is the number of discarded packets with wrong nwid/essid.
-	DiscardedNwid int
-
-	// DiscardedCrypt is the number of discarded packets with wrong code/decode (WEP).
-	DiscardedCrypt int
-
-	// DiscardedFrag is the number of discarded packets that can't perform MAC reassembly.
-	DiscardedFrag int
-
-	// DiscardedRetry is the number of discarded packets that reached max MAC retries.
-	DiscardedRetry int
-
-	// DiscardedMisc is the number of discarded packets for other reasons.
-	DiscardedMisc int
-
-	// MissedBeacon is the number of missed beacons/superframe.
-	MissedBeacon int
-}
-
-// Wireless returns kernel wireless statistics.
-func (fs FS) Wireless() ([]*Wireless, error) {
-	b, err := util.ReadFileNoStat(fs.proc.Path("net/wireless"))
-	if err != nil {
-		return nil, err
-	}
-
-	m, err := parseWireless(bytes.NewReader(b))
-	if err != nil {
-		return nil, fmt.Errorf("%w: wireless: %w", ErrFileParse, err)
-	}
-
-	return m, nil
-}
-
-// parseWireless parses the contents of /proc/net/wireless.
-/*
-Inter-| sta-|   Quality        |   Discarded packets               | Missed | WE
-face | tus | link level noise |  nwid  crypt   frag  retry   misc | beacon | 22
- eth1: 0000    5.  -256.  -10.       0      1      0     3      0        0
- eth2: 0000    5.  -256.  -20.       0      2      0     4      0        0
-*/
-func parseWireless(r io.Reader) ([]*Wireless, error) {
-	var (
-		interfaces []*Wireless
-		scanner    = bufio.NewScanner(r)
-	)
-
-	for n := 0; scanner.Scan(); n++ {
-		// Skip the 2 header lines.
-		if n < 2 {
-			continue
-		}
-
-		line := scanner.Text()
-
-		parts := strings.Split(line, ":")
-		if len(parts) != 2 {
-			return nil, fmt.Errorf("%w: expected 2 parts after splitting line by ':', got %d for line %q", ErrFileParse, len(parts), line)
-		}
-
-		name := strings.TrimSpace(parts[0])
-		stats := strings.Fields(parts[1])
-
-		if len(stats) < 10 {
-			return nil, fmt.Errorf("%w: invalid number of fields in line %d, expected 10+, got %d: %q", ErrFileParse, n, len(stats), line)
-		}
-
-		status, err := strconv.ParseUint(stats[0], 16, 16)
-		if err != nil {
-			return nil, fmt.Errorf("%w: invalid status in line %d: %q", ErrFileParse, n, line)
-		}
-
-		qlink, err := strconv.Atoi(strings.TrimSuffix(stats[1], "."))
-		if err != nil {
-			return nil, fmt.Errorf("%w: parse Quality:link as integer %q: %w", ErrFileParse, qlink, err)
-		}
-
-		qlevel, err := strconv.Atoi(strings.TrimSuffix(stats[2], "."))
-		if err != nil {
-			return nil, fmt.Errorf("%w: Quality:level as integer %q: %w", ErrFileParse, qlevel, err)
-		}
-
-		qnoise, err := strconv.Atoi(strings.TrimSuffix(stats[3], "."))
-		if err != nil {
-			return nil, fmt.Errorf("%w: Quality:noise as integer %q: %w", ErrFileParse, qnoise, err)
-		}
-
-		dnwid, err := strconv.Atoi(stats[4])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:nwid as integer %q: %w", ErrFileParse, dnwid, err)
-		}
-
-		dcrypt, err := strconv.Atoi(stats[5])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:crypt as integer %q: %w", ErrFileParse, dcrypt, err)
-		}
-
-		dfrag, err := strconv.Atoi(stats[6])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:frag as integer %q: %w", ErrFileParse, dfrag, err)
-		}
-
-		dretry, err := strconv.Atoi(stats[7])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:retry as integer %q: %w", ErrFileParse, dretry, err)
-		}
-
-		dmisc, err := strconv.Atoi(stats[8])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Discarded:misc as integer %q: %w", ErrFileParse, dmisc, err)
-		}
-
-		mbeacon, err := strconv.Atoi(stats[9])
-		if err != nil {
-			return nil, fmt.Errorf("%w: Missed:beacon as integer %q: %w", ErrFileParse, mbeacon, err)
-		}
-
-		w := &Wireless{
-			Name:           name,
-			Status:         status,
-			QualityLink:    qlink,
-			QualityLevel:   qlevel,
-			QualityNoise:   qnoise,
-			DiscardedNwid:  dnwid,
-			DiscardedCrypt: dcrypt,
-			DiscardedFrag:  dfrag,
-			DiscardedRetry: dretry,
-			DiscardedMisc:  dmisc,
-			MissedBeacon:   mbeacon,
-		}
-
-		interfaces = append(interfaces, w)
-	}
-
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("%w: Failed to scan /proc/net/wireless: %w", ErrFileRead, err)
-	}
-
-	return interfaces, nil
-}
--- a/vendor/github.com/prometheus/procfs/net_xfrm.go
+++ b/vendor/github.com/prometheus/procfs/net_xfrm.go
@@ -115,7 +115,7 @@ func (fs FS) NewXfrmStat() (XfrmStat, error) {
 		fields := strings.Fields(s.Text())

 		if len(fields) != 2 {
-			return XfrmStat{}, fmt.Errorf("%w: %q line %q", ErrFileParse, file.Name(), s.Text())
+			return XfrmStat{}, fmt.Errorf("couldn't parse %q line %q", file.Name(), s.Text())
 		}

 		name := fields[0]
--- a/vendor/github.com/prometheus/procfs/netstat.go
+++ b/vendor/github.com/prometheus/procfs/netstat.go
@@ -15,6 +15,7 @@ package procfs

 import (
 	"bufio"
+	"io"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -37,7 +38,12 @@ func (fs FS) NetStat() ([]NetStat, error) {
 	var netStatsTotal []NetStat

 	for _, filePath := range statFiles {
-		procNetstat, err := parseNetstat(filePath)
+		file, err := os.Open(filePath)
+		if err != nil {
+			return nil, err
+		}
+
+		procNetstat, err := parseNetstat(file)
 		if err != nil {
 			return nil, err
 		}
@@ -50,17 +56,14 @@ func (fs FS) NetStat() ([]NetStat, error) {

 // parseNetstat parses the metrics from `/proc/net/stat/` file
 // and returns a NetStat structure.
-func parseNetstat(filePath string) (NetStat, error) {
-	netStat := NetStat{
-		Stats: make(map[string][]uint64),
-	}
-	file, err := os.Open(filePath)
-	if err != nil {
-		return netStat, err
-	}
-	defer file.Close()
+func parseNetstat(r io.Reader) (NetStat, error) {
+	var (
+		scanner = bufio.NewScanner(r)
+		netStat = NetStat{
+			Stats: make(map[string][]uint64),
+		}
+	)

-	scanner := bufio.NewScanner(file)
 	scanner.Scan()

 	// First string is always a header for stats
--- a/vendor/github.com/prometheus/procfs/proc.go
+++ b/vendor/github.com/prometheus/procfs/proc.go
@@ -15,13 +15,13 @@ package procfs

 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"os"
 	"strconv"
 	"strings"

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

@@ -30,18 +30,12 @@ type Proc struct {
 	// The process ID.
 	PID int

-	fs FS
+	fs fs.FS
 }

 // Procs represents a list of Proc structs.
 type Procs []Proc

-var (
-	ErrFileParse  = errors.New("Error Parsing File")
-	ErrFileRead   = errors.New("Error Reading File")
-	ErrMountPoint = errors.New("Error Accessing Mount point")
-)
-
 func (p Procs) Len() int           { return len(p) }
 func (p Procs) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
 func (p Procs) Less(i, j int) bool { return p[i].PID < p[j].PID }
@@ -49,7 +43,7 @@ func (p Procs) Less(i, j int) bool { return p[i].PID < p[j].PID }
 // Self returns a process for the current process read via /proc/self.
 func Self() (Proc, error) {
 	fs, err := NewFS(DefaultMountPoint)
-	if err != nil || errors.Unwrap(err) == ErrMountPoint {
+	if err != nil {
 		return Proc{}, err
 	}
 	return fs.Self()
@@ -98,7 +92,7 @@ func (fs FS) Proc(pid int) (Proc, error) {
 	if _, err := os.Stat(fs.proc.Path(strconv.Itoa(pid))); err != nil {
 		return Proc{}, err
 	}
-	return Proc{PID: pid, fs: fs}, nil
+	return Proc{PID: pid, fs: fs.proc}, nil
 }

 // AllProcs returns a list of all currently available processes.
@@ -111,7 +105,7 @@ func (fs FS) AllProcs() (Procs, error) {

 	names, err := d.Readdirnames(-1)
 	if err != nil {
-		return Procs{}, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, names, err)
+		return Procs{}, fmt.Errorf("could not read %q: %w", d.Name(), err)
 	}

 	p := Procs{}
@@ -120,7 +114,7 @@ func (fs FS) AllProcs() (Procs, error) {
 		if err != nil {
 			continue
 		}
-		p = append(p, Proc{PID: int(pid), fs: fs})
+		p = append(p, Proc{PID: int(pid), fs: fs.proc})
 	}

 	return p, nil
@@ -137,7 +131,7 @@ func (p Proc) CmdLine() ([]string, error) {
 		return []string{}, nil
 	}

-	return strings.Split(string(bytes.TrimRight(data, "\x00")), "\x00"), nil
+	return strings.Split(string(bytes.TrimRight(data, string("\x00"))), string(byte(0))), nil
 }

 // Wchan returns the wchan (wait channel) of a process.
@@ -212,7 +206,7 @@ func (p Proc) FileDescriptors() ([]uintptr, error) {
 	for i, n := range names {
 		fd, err := strconv.ParseInt(n, 10, 32)
 		if err != nil {
-			return nil, fmt.Errorf("%w: Cannot parse line: %v: %w", ErrFileParse, i, err)
+			return nil, fmt.Errorf("could not parse fd %q: %w", n, err)
 		}
 		fds[i] = uintptr(fd)
 	}
@@ -243,19 +237,6 @@ func (p Proc) FileDescriptorTargets() ([]string, error) {
 // FileDescriptorsLen returns the number of currently open file descriptors of
 // a process.
 func (p Proc) FileDescriptorsLen() (int, error) {
-	// Use fast path if available (Linux v6.2): https://github.com/torvalds/linux/commit/f1f1f2569901
-	if p.fs.isReal {
-		stat, err := os.Stat(p.path("fd"))
-		if err != nil {
-			return 0, err
-		}
-
-		size := stat.Size()
-		if size > 0 {
-			return int(size), nil
-		}
-	}
-
 	fds, err := p.fileDescriptors()
 	if err != nil {
 		return 0, err
@@ -297,14 +278,14 @@ func (p Proc) fileDescriptors() ([]string, error) {

 	names, err := d.Readdirnames(-1)
 	if err != nil {
-		return nil, fmt.Errorf("%w: Cannot read file: %v: %w", ErrFileRead, names, err)
+		return nil, fmt.Errorf("could not read %q: %w", d.Name(), err)
 	}

 	return names, nil
 }

 func (p Proc) path(pa ...string) string {
-	return p.fs.proc.Path(append([]string{strconv.Itoa(p.PID)}, pa...)...)
+	return p.fs.Path(append([]string{strconv.Itoa(p.PID)}, pa...)...)
 }

 // FileDescriptorsInfo retrieves information about all file descriptors of
--- a/vendor/github.com/prometheus/procfs/proc_cgroup.go
+++ b/vendor/github.com/prometheus/procfs/proc_cgroup.go
@@ -24,7 +24,7 @@ import (
 )

 // Cgroup models one line from /proc/[pid]/cgroup. Each Cgroup struct describes the placement of a PID inside a
-// specific control hierarchy. The kernel has two cgroup APIs, v1 and v2. The v1 has one hierarchy per available resource
+// specific control hierarchy. The kernel has two cgroup APIs, v1 and v2. v1 has one hierarchy per available resource
 // controller, while v2 has one unified hierarchy shared by all controllers. Regardless of v1 or v2, all hierarchies
 // contain all running processes, so the question answerable with a Cgroup struct is 'where is this process in
 // this hierarchy' (where==what path on the specific cgroupfs). By prefixing this path with the mount point of
@@ -51,7 +51,7 @@ func parseCgroupString(cgroupStr string) (*Cgroup, error) {

 	fields := strings.SplitN(cgroupStr, ":", 3)
 	if len(fields) < 3 {
-		return nil, fmt.Errorf("%w: 3+ fields required, found %d fields in cgroup string: %s", ErrFileParse, len(fields), cgroupStr)
+		return nil, fmt.Errorf("at least 3 fields required, found %d fields in cgroup string: %s", len(fields), cgroupStr)
 	}

 	cgroup := &Cgroup{
@@ -60,7 +60,7 @@ func parseCgroupString(cgroupStr string) (*Cgroup, error) {
 	}
 	cgroup.HierarchyID, err = strconv.Atoi(fields[0])
 	if err != nil {
-		return nil, fmt.Errorf("%w: hierarchy ID: %q", ErrFileParse, cgroup.HierarchyID)
+		return nil, fmt.Errorf("failed to parse hierarchy ID")
 	}
 	if fields[1] != "" {
 		ssNames := strings.Split(fields[1], ",")
--- a/vendor/github.com/prometheus/procfs/proc_cgroups.go
+++ b/vendor/github.com/prometheus/procfs/proc_cgroups.go
@@ -46,7 +46,7 @@ func parseCgroupSummaryString(CgroupSummaryStr string) (*CgroupSummary, error) {
 	fields := strings.Fields(CgroupSummaryStr)
 	// require at least 4 fields
 	if len(fields) < 4 {
-		return nil, fmt.Errorf("%w: 4+ fields required, found %d fields in cgroup info string: %s", ErrFileParse, len(fields), CgroupSummaryStr)
+		return nil, fmt.Errorf("at least 4 fields required, found %d fields in cgroup info string: %s", len(fields), CgroupSummaryStr)
 	}

 	CgroupSummary := &CgroupSummary{
@@ -54,15 +54,15 @@ func parseCgroupSummaryString(CgroupSummaryStr string) (*CgroupSummary, error) {
 	}
 	CgroupSummary.Hierarchy, err = strconv.Atoi(fields[1])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse hierarchy ID from %q", ErrFileParse, fields[1])
+		return nil, fmt.Errorf("failed to parse hierarchy ID")
 	}
 	CgroupSummary.Cgroups, err = strconv.Atoi(fields[2])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse Cgroup Num from %q", ErrFileParse, fields[2])
+		return nil, fmt.Errorf("failed to parse Cgroup Num")
 	}
 	CgroupSummary.Enabled, err = strconv.Atoi(fields[3])
 	if err != nil {
-		return nil, fmt.Errorf("%w: Unable to parse Enabled from %q", ErrFileParse, fields[3])
+		return nil, fmt.Errorf("failed to parse Enabled")
 	}
 	return CgroupSummary, nil
 }
--- a/vendor/github.com/prometheus/procfs/proc_fdinfo.go
+++ b/vendor/github.com/prometheus/procfs/proc_fdinfo.go
@@ -26,7 +26,6 @@ var (
 	rPos          = regexp.MustCompile(`^pos:\s+(\d+)$`)
 	rFlags        = regexp.MustCompile(`^flags:\s+(\d+)$`)
 	rMntID        = regexp.MustCompile(`^mnt_id:\s+(\d+)$`)
-	rIno          = regexp.MustCompile(`^ino:\s+(\d+)$`)
 	rInotify      = regexp.MustCompile(`^inotify`)
 	rInotifyParts = regexp.MustCompile(`^inotify\s+wd:([0-9a-f]+)\s+ino:([0-9a-f]+)\s+sdev:([0-9a-f]+)(?:\s+mask:([0-9a-f]+))?`)
 )
@@ -41,8 +40,6 @@ type ProcFDInfo struct {
 	Flags string
 	// Mount point ID
 	MntID string
-	// Inode number
-	Ino string
 	// List of inotify lines (structured) in the fdinfo file (kernel 3.8+ only)
 	InotifyInfos []InotifyInfo
 }
@@ -54,7 +51,7 @@ func (p Proc) FDInfo(fd string) (*ProcFDInfo, error) {
 		return nil, err
 	}

-	var text, pos, flags, mntid, ino string
+	var text, pos, flags, mntid string
 	var inotify []InotifyInfo

 	scanner := bufio.NewScanner(bytes.NewReader(data))
@@ -66,8 +63,6 @@ func (p Proc) FDInfo(fd string) (*ProcFDInfo, error) {
 			flags = rFlags.FindStringSubmatch(text)[1]
 		} else if rMntID.MatchString(text) {
 			mntid = rMntID.FindStringSubmatch(text)[1]
-		} else if rIno.MatchString(text) {
-			ino = rIno.FindStringSubmatch(text)[1]
 		} else if rInotify.MatchString(text) {
 			newInotify, err := parseInotifyInfo(text)
 			if err != nil {
@@ -82,7 +77,6 @@ func (p Proc) FDInfo(fd string) (*ProcFDInfo, error) {
 		Pos:          pos,
 		Flags:        flags,
 		MntID:        mntid,
-		Ino:          ino,
 		InotifyInfos: inotify,
 	}

@@ -117,7 +111,7 @@ func parseInotifyInfo(line string) (*InotifyInfo, error) {
 		}
 		return i, nil
 	}
-	return nil, fmt.Errorf("%w: invalid inode entry: %q", ErrFileParse, line)
+	return nil, fmt.Errorf("invalid inode entry: %q", line)
 }

 // ProcFDInfos represents a list of ProcFDInfo structs.
--- a/vendor/github.com/prometheus/procfs/proc_interrupts.go
+++ b/vendor/github.com/prometheus/procfs/proc_interrupts.go
@@ -66,7 +66,7 @@ func parseInterrupts(r io.Reader) (Interrupts, error) {
 			continue
 		}
 		if len(parts) < 2 {
-			return nil, fmt.Errorf("%w: Not enough fields in interrupts (expected 2+ fields but got %d): %s", ErrFileParse, len(parts), parts)
+			return nil, fmt.Errorf("not enough fields in interrupts (expected at least 2 fields but got %d): %s", len(parts), parts)
 		}
 		intName := parts[0][:len(parts[0])-1] // remove trailing :

--- a/vendor/github.com/prometheus/procfs/proc_io.go
+++ b/vendor/github.com/prometheus/procfs/proc_io.go
@@ -50,7 +50,7 @@ func (p Proc) IO() (ProcIO, error) {

 	ioFormat := "rchar: %d\nwchar: %d\nsyscr: %d\nsyscw: %d\n" +
 		"read_bytes: %d\nwrite_bytes: %d\n" +
-		"cancelled_write_bytes: %d\n" //nolint:misspell
+		"cancelled_write_bytes: %d\n"

 	_, err = fmt.Sscanf(string(data), ioFormat, &pio.RChar, &pio.WChar, &pio.SyscR,
 		&pio.SyscW, &pio.ReadBytes, &pio.WriteBytes, &pio.CancelledWriteBytes)
--- a/vendor/github.com/prometheus/procfs/proc_limits.go
+++ b/vendor/github.com/prometheus/procfs/proc_limits.go
@@ -103,7 +103,7 @@ func (p Proc) Limits() (ProcLimits, error) {
 		//fields := limitsMatch.Split(s.Text(), limitsFields)
 		fields := limitsMatch.FindStringSubmatch(s.Text())
 		if len(fields) != limitsFields {
-			return ProcLimits{}, fmt.Errorf("%w: couldn't parse %q line %q", ErrFileParse, f.Name(), s.Text())
+			return ProcLimits{}, fmt.Errorf("couldn't parse %q line %q", f.Name(), s.Text())
 		}

 		switch fields[1] {
@@ -154,7 +154,7 @@ func parseUint(s string) (uint64, error) {
 	}
 	i, err := strconv.ParseUint(s, 10, 64)
 	if err != nil {
-		return 0, fmt.Errorf("%w: couldn't parse value %q: %w", ErrFileParse, s, err)
+		return 0, fmt.Errorf("couldn't parse value %q: %w", s, err)
 	}
 	return i, nil
 }
--- a/vendor/github.com/prometheus/procfs/proc_maps.go
+++ b/vendor/github.com/prometheus/procfs/proc_maps.go
@@ -63,17 +63,17 @@ type ProcMap struct {
 // parseDevice parses the device token of a line and converts it to a dev_t
 // (mkdev) like structure.
 func parseDevice(s string) (uint64, error) {
-	i := strings.Index(s, ":")
-	if i == -1 {
-		return 0, fmt.Errorf("%w: expected separator `:` in %s", ErrFileParse, s)
+	toks := strings.Split(s, ":")
+	if len(toks) < 2 {
+		return 0, fmt.Errorf("unexpected number of fields")
 	}

-	major, err := strconv.ParseUint(s[0:i], 16, 0)
+	major, err := strconv.ParseUint(toks[0], 16, 0)
 	if err != nil {
 		return 0, err
 	}

-	minor, err := strconv.ParseUint(s[i+1:], 16, 0)
+	minor, err := strconv.ParseUint(toks[1], 16, 0)
 	if err != nil {
 		return 0, err
 	}
@@ -93,17 +93,17 @@ func parseAddress(s string) (uintptr, error) {

 // parseAddresses parses the start-end address.
 func parseAddresses(s string) (uintptr, uintptr, error) {
-	idx := strings.Index(s, "-")
-	if idx == -1 {
-		return 0, 0, fmt.Errorf("%w: expected separator `-` in %s", ErrFileParse, s)
+	toks := strings.Split(s, "-")
+	if len(toks) < 2 {
+		return 0, 0, fmt.Errorf("invalid address")
 	}

-	saddr, err := parseAddress(s[0:idx])
+	saddr, err := parseAddress(toks[0])
 	if err != nil {
 		return 0, 0, err
 	}

-	eaddr, err := parseAddress(s[idx+1:])
+	eaddr, err := parseAddress(toks[1])
 	if err != nil {
 		return 0, 0, err
 	}
@@ -114,7 +114,7 @@ func parseAddresses(s string) (uintptr, uintptr, error) {
 // parsePermissions parses a token and returns any that are set.
 func parsePermissions(s string) (*ProcMapPermissions, error) {
 	if len(s) < 4 {
-		return nil, fmt.Errorf("%w: invalid permissions token", ErrFileParse)
+		return nil, fmt.Errorf("invalid permissions token")
 	}

 	perms := ProcMapPermissions{}
@@ -141,7 +141,7 @@ func parsePermissions(s string) (*ProcMapPermissions, error) {
 func parseProcMap(text string) (*ProcMap, error) {
 	fields := strings.Fields(text)
 	if len(fields) < 5 {
-		return nil, fmt.Errorf("%w: truncated procmap entry", ErrFileParse)
+		return nil, fmt.Errorf("truncated procmap entry")
 	}

 	saddr, eaddr, err := parseAddresses(fields[0])
--- a/vendor/github.com/prometheus/procfs/proc_netstat.go
+++ b/vendor/github.com/prometheus/procfs/proc_netstat.go
@@ -195,8 +195,8 @@ func parseProcNetstat(r io.Reader, fileName string) (ProcNetstat, error) {
 		// Remove trailing :.
 		protocol := strings.TrimSuffix(nameParts[0], ":")
 		if len(nameParts) != len(valueParts) {
-			return procNetstat, fmt.Errorf("%w: mismatch field count mismatch in %s: %s",
-				ErrFileParse, fileName, protocol)
+			return procNetstat, fmt.Errorf("mismatch field count mismatch in %s: %s",
+				fileName, protocol)
 		}
 		for i := 1; i < len(nameParts); i++ {
 			value, err := strconv.ParseFloat(valueParts[i], 64)
--- a/vendor/github.com/prometheus/procfs/proc_ns.go
+++ b/vendor/github.com/prometheus/procfs/proc_ns.go
@@ -40,7 +40,7 @@ func (p Proc) Namespaces() (Namespaces, error) {

 	names, err := d.Readdirnames(-1)
 	if err != nil {
-		return nil, fmt.Errorf("%w: failed to read contents of ns dir: %w", ErrFileRead, err)
+		return nil, fmt.Errorf("failed to read contents of ns dir: %w", err)
 	}

 	ns := make(Namespaces, len(names))
@@ -52,13 +52,13 @@ func (p Proc) Namespaces() (Namespaces, error) {

 		fields := strings.SplitN(target, ":", 2)
 		if len(fields) != 2 {
-			return nil, fmt.Errorf("%w: namespace type and inode from %q", ErrFileParse, target)
+			return nil, fmt.Errorf("failed to parse namespace type and inode from %q", target)
 		}

 		typ := fields[0]
 		inode, err := strconv.ParseUint(strings.Trim(fields[1], "[]"), 10, 32)
 		if err != nil {
-			return nil, fmt.Errorf("%w: inode from %q: %w", ErrFileParse, fields[1], err)
+			return nil, fmt.Errorf("failed to parse inode from %q: %w", fields[1], err)
 		}

 		ns[name] = Namespace{typ, uint32(inode)}
--- a/vendor/github.com/prometheus/procfs/proc_psi.go
+++ b/vendor/github.com/prometheus/procfs/proc_psi.go
@@ -61,14 +61,14 @@ type PSIStats struct {
 func (fs FS) PSIStatsForResource(resource string) (PSIStats, error) {
 	data, err := util.ReadFileNoStat(fs.proc.Path(fmt.Sprintf("%s/%s", "pressure", resource)))
 	if err != nil {
-		return PSIStats{}, fmt.Errorf("%w: psi_stats: unavailable for %q: %w", ErrFileRead, resource, err)
+		return PSIStats{}, fmt.Errorf("psi_stats: unavailable for %q: %w", resource, err)
 	}

-	return parsePSIStats(bytes.NewReader(data))
+	return parsePSIStats(resource, bytes.NewReader(data))
 }

 // parsePSIStats parses the specified file for pressure stall information.
-func parsePSIStats(r io.Reader) (PSIStats, error) {
+func parsePSIStats(resource string, r io.Reader) (PSIStats, error) {
 	psiStats := PSIStats{}

 	scanner := bufio.NewScanner(r)
--- a/vendor/github.com/prometheus/procfs/proc_smaps.go
+++ b/vendor/github.com/prometheus/procfs/proc_smaps.go
@@ -19,6 +19,7 @@ package procfs
 import (
 	"bufio"
 	"errors"
+	"fmt"
 	"os"
 	"regexp"
 	"strconv"
@@ -28,7 +29,7 @@ import (
 )

 var (
-	// Match the header line before each mapped zone in `/proc/pid/smaps`.
+	// match the header line before each mapped zone in `/proc/pid/smaps`.
 	procSMapsHeaderLine = regexp.MustCompile(`^[a-f0-9].*$`)
 )

@@ -116,6 +117,7 @@ func (p Proc) procSMapsRollupManual() (ProcSMapsRollup, error) {
 func (s *ProcSMapsRollup) parseLine(line string) error {
 	kv := strings.SplitN(line, ":", 2)
 	if len(kv) != 2 {
+		fmt.Println(line)
 		return errors.New("invalid net/dev line, missing colon")
 	}

@@ -125,7 +127,7 @@ func (s *ProcSMapsRollup) parseLine(line string) error {
 	}

 	v := strings.TrimSpace(kv[1])
-	v = strings.TrimSuffix(v, " kB")
+	v = strings.TrimRight(v, " kB")

 	vKBytes, err := strconv.ParseUint(v, 10, 64)
 	if err != nil {
@@ -133,12 +135,12 @@ func (s *ProcSMapsRollup) parseLine(line string) error {
 	}
 	vBytes := vKBytes * 1024

-	s.addValue(k, vBytes)
+	s.addValue(k, v, vKBytes, vBytes)

 	return nil
 }

-func (s *ProcSMapsRollup) addValue(k string, vUintBytes uint64) {
+func (s *ProcSMapsRollup) addValue(k string, vString string, vUint uint64, vUintBytes uint64) {
 	switch k {
 	case "Rss":
 		s.Rss += vUintBytes
--- a/vendor/github.com/prometheus/procfs/proc_snmp.go
+++ b/vendor/github.com/prometheus/procfs/proc_snmp.go
@@ -159,8 +159,8 @@ func parseSnmp(r io.Reader, fileName string) (ProcSnmp, error) {
 		// Remove trailing :.
 		protocol := strings.TrimSuffix(nameParts[0], ":")
 		if len(nameParts) != len(valueParts) {
-			return procSnmp, fmt.Errorf("%w: mismatch field count mismatch in %s: %s",
-				ErrFileParse, fileName, protocol)
+			return procSnmp, fmt.Errorf("mismatch field count mismatch in %s: %s",
+				fileName, protocol)
 		}
 		for i := 1; i < len(nameParts); i++ {
 			value, err := strconv.ParseFloat(valueParts[i], 64)
--- a/vendor/github.com/prometheus/procfs/proc_stat.go
+++ b/vendor/github.com/prometheus/procfs/proc_stat.go
@@ -18,6 +18,7 @@ import (
 	"fmt"
 	"os"

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

@@ -110,13 +111,8 @@ type ProcStat struct {
 	Policy uint
 	// Aggregated block I/O delays, measured in clock ticks (centiseconds).
 	DelayAcctBlkIOTicks uint64
-	// Guest time of the process (time spent running a virtual CPU for a guest
-	// operating system), measured in clock ticks.
-	GuestTime int
-	// Guest time of the process's children, measured in clock ticks.
-	CGuestTime int

-	proc FS
+	proc fs.FS
 }

 // NewStat returns the current status information of the process.
@@ -143,7 +139,7 @@ func (p Proc) Stat() (ProcStat, error) {
 	)

 	if l < 0 || r < 0 {
-		return ProcStat{}, fmt.Errorf("%w: unexpected format, couldn't extract comm %q", ErrFileParse, data)
+		return ProcStat{}, fmt.Errorf("unexpected format, couldn't extract comm %q", data)
 	}

 	s.Comm = string(data[l+1 : r])
@@ -194,8 +190,6 @@ func (p Proc) Stat() (ProcStat, error) {
 		&s.RTPriority,
 		&s.Policy,
 		&s.DelayAcctBlkIOTicks,
-		&s.GuestTime,
-		&s.CGuestTime,
 	)
 	if err != nil {
 		return ProcStat{}, err
@@ -216,7 +210,8 @@ func (s ProcStat) ResidentMemory() int {

 // StartTime returns the unix timestamp of the process in seconds.
 func (s ProcStat) StartTime() (float64, error) {
-	stat, err := s.proc.Stat()
+	fs := FS{proc: s.proc}
+	stat, err := fs.Stat()
 	if err != nil {
 		return 0, err
 	}
--- a/vendor/github.com/prometheus/procfs/proc_status.go
+++ b/vendor/github.com/prometheus/procfs/proc_status.go
@@ -15,8 +15,6 @@ package procfs

 import (
 	"bytes"
-	"math/bits"
-	"sort"
 	"strconv"
 	"strings"

@@ -24,7 +22,7 @@ import (
 )

 // ProcStatus provides status information about the process,
-// read from /proc/[pid]/status.
+// read from /proc/[pid]/stat.
 type ProcStatus struct {
 	// The process ID.
 	PID int
@@ -33,8 +31,6 @@ type ProcStatus struct {

 	// Thread group ID.
 	TGID int
-	// List of Pid namespace.
-	NSpids []uint64

 	// Peak virtual memory size.
 	VmPeak uint64 // nolint:revive
@@ -77,12 +73,9 @@ type ProcStatus struct {
 	NonVoluntaryCtxtSwitches uint64

 	// UIDs of the process (Real, effective, saved set, and filesystem UIDs)
-	UIDs [4]uint64
+	UIDs [4]string
 	// GIDs of the process (Real, effective, saved set, and filesystem GIDs)
-	GIDs [4]uint64
-
-	// CpusAllowedList: List of cpu cores processes are allowed to run on.
-	CpusAllowedList []uint64
+	GIDs [4]string
 }

 // NewStatus returns the current status information of the process.
@@ -114,43 +107,22 @@ func (p Proc) NewStatus() (ProcStatus, error) {
 		// convert kB to B
 		vBytes := vKBytes * 1024

-		err = s.fillStatus(k, v, vKBytes, vBytes)
-		if err != nil {
-			return ProcStatus{}, err
-		}
+		s.fillStatus(k, v, vKBytes, vBytes)
 	}

 	return s, nil
 }

-func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintBytes uint64) error {
+func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintBytes uint64) {
 	switch k {
 	case "Tgid":
 		s.TGID = int(vUint)
 	case "Name":
 		s.Name = vString
 	case "Uid":
-		var err error
-		for i, v := range strings.Split(vString, "\t") {
-			s.UIDs[i], err = strconv.ParseUint(v, 10, bits.UintSize)
-			if err != nil {
-				return err
-			}
-		}
+		copy(s.UIDs[:], strings.Split(vString, "\t"))
 	case "Gid":
-		var err error
-		for i, v := range strings.Split(vString, "\t") {
-			s.GIDs[i], err = strconv.ParseUint(v, 10, bits.UintSize)
-			if err != nil {
-				return err
-			}
-		}
-	case "NSpid":
-		nspids, err := calcNSPidsList(vString)
-		if err != nil {
-			return err
-		}
-		s.NSpids = nspids
+		copy(s.GIDs[:], strings.Split(vString, "\t"))
 	case "VmPeak":
 		s.VmPeak = vUintBytes
 	case "VmSize":
@@ -189,54 +161,10 @@ func (s *ProcStatus) fillStatus(k string, vString string, vUint uint64, vUintByt
 		s.VoluntaryCtxtSwitches = vUint
 	case "nonvoluntary_ctxt_switches":
 		s.NonVoluntaryCtxtSwitches = vUint
-	case "Cpus_allowed_list":
-		s.CpusAllowedList = calcCpusAllowedList(vString)
 	}
-
-	return nil
 }

 // TotalCtxtSwitches returns the total context switch.
 func (s ProcStatus) TotalCtxtSwitches() uint64 {
 	return s.VoluntaryCtxtSwitches + s.NonVoluntaryCtxtSwitches
 }
-
-func calcCpusAllowedList(cpuString string) []uint64 {
-	s := strings.Split(cpuString, ",")
-
-	var g []uint64
-
-	for _, cpu := range s {
-		// parse cpu ranges, example: 1-3=[1,2,3]
-		if l := strings.Split(strings.TrimSpace(cpu), "-"); len(l) > 1 {
-			startCPU, _ := strconv.ParseUint(l[0], 10, 64)
-			endCPU, _ := strconv.ParseUint(l[1], 10, 64)
-
-			for i := startCPU; i <= endCPU; i++ {
-				g = append(g, i)
-			}
-		} else if len(l) == 1 {
-			cpu, _ := strconv.ParseUint(l[0], 10, 64)
-			g = append(g, cpu)
-		}
-
-	}
-
-	sort.Slice(g, func(i, j int) bool { return g[i] < g[j] })
-	return g
-}
-
-func calcNSPidsList(nspidsString string) ([]uint64, error) {
-	s := strings.Split(nspidsString, "\t")
-	var nspids []uint64
-
-	for _, nspid := range s {
-		nspid, err := strconv.ParseUint(nspid, 10, 64)
-		if err != nil {
-			return nil, err
-		}
-		nspids = append(nspids, nspid)
-	}
-
-	return nspids, nil
-}
--- a/vendor/github.com/prometheus/procfs/proc_sys.go
+++ b/vendor/github.com/prometheus/procfs/proc_sys.go
@@ -44,7 +44,7 @@ func (fs FS) SysctlInts(sysctl string) ([]int, error) {
 		vp := util.NewValueParser(f)
 		values[i] = vp.Int()
 		if err := vp.Err(); err != nil {
-			return nil, fmt.Errorf("%w: field %d in sysctl %s is not a valid int: %w", ErrFileParse, i, sysctl, err)
+			return nil, fmt.Errorf("field %d in sysctl %s is not a valid int: %w", i, sysctl, err)
 		}
 	}
 	return values, nil
--- a/vendor/github.com/prometheus/procfs/slab.go
+++ b/vendor/github.com/prometheus/procfs/slab.go
@@ -68,7 +68,7 @@ func parseV21SlabEntry(line string) (*Slab, error) {
 	l := slabSpace.ReplaceAllString(line, " ")
 	s := strings.Split(l, " ")
 	if len(s) != 16 {
-		return nil, fmt.Errorf("%w: unable to parse: %q", ErrFileParse, line)
+		return nil, fmt.Errorf("unable to parse: %q", line)
 	}
 	var err error
 	i := &Slab{Name: s[0]}
--- a/vendor/github.com/prometheus/procfs/softirqs.go
+++ b/vendor/github.com/prometheus/procfs/softirqs.go
@@ -57,7 +57,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 	)

 	if !scanner.Scan() {
-		return Softirqs{}, fmt.Errorf("%w: softirqs empty", ErrFileRead)
+		return Softirqs{}, fmt.Errorf("softirqs empty")
 	}

 	for scanner.Scan() {
@@ -74,7 +74,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.Hi = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.Hi[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (HI%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (HI%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "TIMER:":
@@ -82,7 +82,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.Timer = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.Timer[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (TIMER%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (TIMER%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "NET_TX:":
@@ -90,7 +90,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.NetTx = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.NetTx[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (NET_TX%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (NET_TX%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "NET_RX:":
@@ -98,7 +98,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.NetRx = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.NetRx[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (NET_RX%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (NET_RX%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "BLOCK:":
@@ -106,7 +106,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.Block = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.Block[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (BLOCK%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (BLOCK%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "IRQ_POLL:":
@@ -114,7 +114,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.IRQPoll = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.IRQPoll[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (IRQ_POLL%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (IRQ_POLL%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "TASKLET:":
@@ -122,7 +122,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.Tasklet = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.Tasklet[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (TASKLET%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (TASKLET%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "SCHED:":
@@ -130,7 +130,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.Sched = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.Sched[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (SCHED%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (SCHED%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "HRTIMER:":
@@ -138,7 +138,7 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.HRTimer = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.HRTimer[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (HRTIMER%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (HRTIMER%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "RCU:":
@@ -146,14 +146,14 @@ func parseSoftirqs(r io.Reader) (Softirqs, error) {
 			softirqs.RCU = make([]uint64, len(perCPU))
 			for i, count := range perCPU {
 				if softirqs.RCU[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Softirqs{}, fmt.Errorf("%w: couldn't parse %q (RCU%d): %w", ErrFileParse, count, i, err)
+					return Softirqs{}, fmt.Errorf("couldn't parse %q (RCU%d): %w", count, i, err)
 				}
 			}
 		}
 	}

 	if err := scanner.Err(); err != nil {
-		return Softirqs{}, fmt.Errorf("%w: couldn't parse softirqs: %w", ErrFileParse, err)
+		return Softirqs{}, fmt.Errorf("couldn't parse softirqs: %w", err)
 	}

 	return softirqs, scanner.Err()
--- a/vendor/github.com/prometheus/procfs/stat.go
+++ b/vendor/github.com/prometheus/procfs/stat.go
@@ -93,10 +93,10 @@ func parseCPUStat(line string) (CPUStat, int64, error) {
 		&cpuStat.Guest, &cpuStat.GuestNice)

 	if err != nil && err != io.EOF {
-		return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu): %w", ErrFileParse, line, err)
+		return CPUStat{}, -1, fmt.Errorf("couldn't parse %q (cpu): %w", line, err)
 	}
 	if count == 0 {
-		return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu): 0 elements parsed", ErrFileParse, line)
+		return CPUStat{}, -1, fmt.Errorf("couldn't parse %q (cpu): 0 elements parsed", line)
 	}

 	cpuStat.User /= userHZ
@@ -116,7 +116,7 @@ func parseCPUStat(line string) (CPUStat, int64, error) {

 	cpuID, err := strconv.ParseInt(cpu[3:], 10, 64)
 	if err != nil {
-		return CPUStat{}, -1, fmt.Errorf("%w: couldn't parse %q (cpu/cpuid): %w", ErrFileParse, line, err)
+		return CPUStat{}, -1, fmt.Errorf("couldn't parse %q (cpu/cpuid): %w", line, err)
 	}

 	return cpuStat, cpuID, nil
@@ -136,7 +136,7 @@ func parseSoftIRQStat(line string) (SoftIRQStat, uint64, error) {
 		&softIRQStat.Hrtimer, &softIRQStat.Rcu)

 	if err != nil {
-		return SoftIRQStat{}, 0, fmt.Errorf("%w: couldn't parse %q (softirq): %w", ErrFileParse, line, err)
+		return SoftIRQStat{}, 0, fmt.Errorf("couldn't parse %q (softirq): %w", line, err)
 	}

 	return softIRQStat, total, nil
@@ -187,10 +187,6 @@ func parseStat(r io.Reader, fileName string) (Stat, error) {
 		err error
 	)

-	// Increase default scanner buffer to handle very long `intr` lines.
-	buf := make([]byte, 0, 8*1024)
-	scanner.Buffer(buf, 1024*1024)
-
 	for scanner.Scan() {
 		line := scanner.Text()
 		parts := strings.Fields(scanner.Text())
@@ -201,34 +197,34 @@ func parseStat(r io.Reader, fileName string) (Stat, error) {
 		switch {
 		case parts[0] == "btime":
 			if stat.BootTime, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (btime): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (btime): %w", parts[1], err)
 			}
 		case parts[0] == "intr":
 			if stat.IRQTotal, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (intr): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (intr): %w", parts[1], err)
 			}
 			numberedIRQs := parts[2:]
 			stat.IRQ = make([]uint64, len(numberedIRQs))
 			for i, count := range numberedIRQs {
 				if stat.IRQ[i], err = strconv.ParseUint(count, 10, 64); err != nil {
-					return Stat{}, fmt.Errorf("%w: couldn't parse %q (intr%d): %w", ErrFileParse, count, i, err)
+					return Stat{}, fmt.Errorf("couldn't parse %q (intr%d): %w", count, i, err)
 				}
 			}
 		case parts[0] == "ctxt":
 			if stat.ContextSwitches, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (ctxt): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (ctxt): %w", parts[1], err)
 			}
 		case parts[0] == "processes":
 			if stat.ProcessCreated, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (processes): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (processes): %w", parts[1], err)
 			}
 		case parts[0] == "procs_running":
 			if stat.ProcessesRunning, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (procs_running): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (procs_running): %w", parts[1], err)
 			}
 		case parts[0] == "procs_blocked":
 			if stat.ProcessesBlocked, err = strconv.ParseUint(parts[1], 10, 64); err != nil {
-				return Stat{}, fmt.Errorf("%w: couldn't parse %q (procs_blocked): %w", ErrFileParse, parts[1], err)
+				return Stat{}, fmt.Errorf("couldn't parse %q (procs_blocked): %w", parts[1], err)
 			}
 		case parts[0] == "softirq":
 			softIRQStats, total, err := parseSoftIRQStat(line)
@@ -251,7 +247,7 @@ func parseStat(r io.Reader, fileName string) (Stat, error) {
 	}

 	if err := scanner.Err(); err != nil {
-		return Stat{}, fmt.Errorf("%w: couldn't parse %q: %w", ErrFileParse, fileName, err)
+		return Stat{}, fmt.Errorf("couldn't parse %q: %w", fileName, err)
 	}

 	return stat, nil
--- a/vendor/github.com/prometheus/procfs/swaps.go
+++ b/vendor/github.com/prometheus/procfs/swaps.go
@@ -64,7 +64,7 @@ func parseSwapString(swapString string) (*Swap, error) {
 	swapFields := strings.Fields(swapString)
 	swapLength := len(swapFields)
 	if swapLength < 5 {
-		return nil, fmt.Errorf("%w: too few fields in swap string: %s", ErrFileParse, swapString)
+		return nil, fmt.Errorf("too few fields in swap string: %s", swapString)
 	}

 	swap := &Swap{
@@ -74,15 +74,15 @@ func parseSwapString(swapString string) (*Swap, error) {

 	swap.Size, err = strconv.Atoi(swapFields[2])
 	if err != nil {
-		return nil, fmt.Errorf("%w: invalid swap size: %s: %w", ErrFileParse, swapFields[2], err)
+		return nil, fmt.Errorf("invalid swap size: %s", swapFields[2])
 	}
 	swap.Used, err = strconv.Atoi(swapFields[3])
 	if err != nil {
-		return nil, fmt.Errorf("%w: invalid swap used: %s: %w", ErrFileParse, swapFields[3], err)
+		return nil, fmt.Errorf("invalid swap used: %s", swapFields[3])
 	}
 	swap.Priority, err = strconv.Atoi(swapFields[4])
 	if err != nil {
-		return nil, fmt.Errorf("%w: invalid swap priority: %s: %w", ErrFileParse, swapFields[4], err)
+		return nil, fmt.Errorf("invalid swap priority: %s", swapFields[4])
 	}

 	return swap, nil
--- a/vendor/github.com/prometheus/procfs/thread.go
+++ b/vendor/github.com/prometheus/procfs/thread.go
@@ -45,7 +45,7 @@ func (fs FS) AllThreads(pid int) (Procs, error) {

 	names, err := d.Readdirnames(-1)
 	if err != nil {
-		return Procs{}, fmt.Errorf("%w: could not read %q: %w", ErrFileRead, d.Name(), err)
+		return Procs{}, fmt.Errorf("could not read %q: %w", d.Name(), err)
 	}

 	t := Procs{}
@@ -54,8 +54,7 @@ func (fs FS) AllThreads(pid int) (Procs, error) {
 		if err != nil {
 			continue
 		}
-
-		t = append(t, Proc{PID: int(tid), fs: FS{fsi.FS(taskPath), fs.isReal}})
+		t = append(t, Proc{PID: int(tid), fs: fsi.FS(taskPath)})
 	}

 	return t, nil
@@ -67,13 +66,13 @@ func (fs FS) Thread(pid, tid int) (Proc, error) {
 	if _, err := os.Stat(taskPath); err != nil {
 		return Proc{}, err
 	}
-	return Proc{PID: tid, fs: FS{fsi.FS(taskPath), fs.isReal}}, nil
+	return Proc{PID: tid, fs: fsi.FS(taskPath)}, nil
 }

 // Thread returns a process for a given TID of Proc.
 func (proc Proc) Thread(tid int) (Proc, error) {
-	tfs := FS{fsi.FS(proc.path("task")), proc.fs.isReal}
-	if _, err := os.Stat(tfs.proc.Path(strconv.Itoa(tid))); err != nil {
+	tfs := fsi.FS(proc.path("task"))
+	if _, err := os.Stat(tfs.Path(strconv.Itoa(tid))); err != nil {
 		return Proc{}, err
 	}
 	return Proc{PID: tid, fs: tfs}, nil
--- a/vendor/github.com/prometheus/procfs/vm.go
+++ b/vendor/github.com/prometheus/procfs/vm.go
@@ -86,7 +86,7 @@ func (fs FS) VM() (*VM, error) {
 		return nil, err
 	}
 	if !file.Mode().IsDir() {
-		return nil, fmt.Errorf("%w: %s is not a directory", ErrFileRead, path)
+		return nil, fmt.Errorf("%s is not a directory", path)
 	}

 	files, err := os.ReadDir(path)
--- a/vendor/github.com/prometheus/procfs/zoneinfo.go
+++ b/vendor/github.com/prometheus/procfs/zoneinfo.go
@@ -75,11 +75,11 @@ var nodeZoneRE = regexp.MustCompile(`(\d+), zone\s+(\w+)`)
 func (fs FS) Zoneinfo() ([]Zoneinfo, error) {
 	data, err := os.ReadFile(fs.proc.Path("zoneinfo"))
 	if err != nil {
-		return nil, fmt.Errorf("%w: error reading zoneinfo %q: %w", ErrFileRead, fs.proc.Path("zoneinfo"), err)
+		return nil, fmt.Errorf("error reading zoneinfo %q: %w", fs.proc.Path("zoneinfo"), err)
 	}
 	zoneinfo, err := parseZoneinfo(data)
 	if err != nil {
-		return nil, fmt.Errorf("%w: error parsing zoneinfo %q: %w", ErrFileParse, fs.proc.Path("zoneinfo"), err)
+		return nil, fmt.Errorf("error parsing zoneinfo %q: %w", fs.proc.Path("zoneinfo"), err)
 	}
 	return zoneinfo, nil
 }