98 files changed, 2748 insertions, 220 deletions
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7f32b94..9d45de4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,18 @@
 ## master / unreleased
+* [CHANGE] Improve filter flag names.
 * [CHANGE]
 * [FEATURE]
-* [ENHANCEMENT]
+* [ENHANCEMENT] Include TCP OutRsts in netstat metrics
 * [BUGFIX]
+## 1.0.1 / 2020-06-15
+* [BUGFIX] filesystem_freebsd: Fix label values #1728
+* [BUGFIX] Update prometheus/procfs to fix log noise #1735
+* [BUGFIX] Fix build tags for collectors #1745
+* [BUGFIX] Handle no data from powersupplyclass #1747, #1749
 ## 1.0.0 / 2020-05-25
 ### **Breaking changes**
diff --git a/Makefile b/Makefile
index daa51ff..504ed3d 100644
--- a/Makefile
+++ b/Makefile
@@ -19,7 +19,7 @@ DOCKER_ARCHS ?= amd64 armv7 arm64 ppc64le s390x
 include Makefile.common
-PROMTOOL_VERSION ?= 2.5.0
+PROMTOOL_VERSION ?= 2.18.1
 PROMTOOL_URL     ?= https://github.com/prometheus/prometheus/releases/download/v$(PROMTOOL_VERSION)/prometheus-$(PROMTOOL_VERSION).$(GO_BUILD_PLATFORM).tar.gz
 PROMTOOL         ?= $(FIRST_GOPATH)/bin/promtool
@@ -129,9 +129,5 @@ test-docker:
 promtool: $(PROMTOOL)
 $(PROMTOOL):
-        $(eval PROMTOOL_TMP := $(shell mktemp -d))
-        curl -s -L $(PROMTOOL_URL) | tar -xvzf - -C $(PROMTOOL_TMP)
        mkdir -p $(FIRST_GOPATH)/bin
-        cp $(PROMTOOL_TMP)/prometheus-$(PROMTOOL_VERSION).$(GO_BUILD_PLATFORM)/promtool $(FIRST_GOPATH)/bin/promtool
+        curl -fsS -L $(PROMTOOL_URL) | tar -xvzf - -C $(FIRST_GOPATH)/bin --no-anchored --strip 1 promtool
-        rm -r $(PROMTOOL_TMP)
diff --git a/VERSION b/VERSION
index 3eefcb9..7dea76e 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-1.0.0
+1.0.1
diff --git a/checkmetrics.sh b/checkmetrics.sh
index 5d846cc..c3104ca 100755
--- a/checkmetrics.sh
+++ b/checkmetrics.sh
@@ -5,14 +5,12 @@ if [[ ( -z "$1" ) || ( -z "$2" ) ]]; then
    exit 1
 fi
-# Only check node_exporter's metrics, as the Prometheus Go client currently
+# Ignore known issues in auto-generated and network specific collectors.
-# exposes a metric with a unit of microseconds.  Once that is fixed, remove
+lint=$($1 check metrics < "$2" 2>&1 | grep -v -E "^node_(entropy|memory|netstat|wifi_station)_")
-# this filter.
-lint=$($1 check metrics < $2 2>&1 | grep "node_")
-if [[ ! -z $lint ]]; then
+if [[ -n $lint ]]; then
    echo -e "Some Prometheus metrics do not follow best practices:\n"
    echo "$lint"
    exit 1
-fi
-\ No newline at end of file
+fi
diff --git a/collector/arp_linux.go b/collector/arp_linux.go
index 6a18879..86cb78a 100644
--- a/collector/arp_linux.go
+++ b/collector/arp_linux.go
@@ -84,7 +84,7 @@ func parseARPEntries(data io.Reader) (map[string]uint32, error) {
        }
        if err := scanner.Err(); err != nil {
-                return nil, fmt.Errorf("failed to parse ARP info: %s", err)
+                return nil, fmt.Errorf("failed to parse ARP info: %w", err)
        }
        return entries, nil
@@ -93,7 +93,7 @@ func parseARPEntries(data io.Reader) (map[string]uint32, error) {
 func (c *arpCollector) Update(ch chan<- prometheus.Metric) error {
        entries, err := getARPEntries()
        if err != nil {
-                return fmt.Errorf("could not get ARP entries: %s", err)
+                return fmt.Errorf("could not get ARP entries: %w", err)
        }
        for device, entryCount := range entries {
diff --git a/collector/bonding_linux.go b/collector/bonding_linux.go
index 78e94b2..863f62c 100644
--- a/collector/bonding_linux.go
+++ b/collector/bonding_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "io/ioutil"
        "os"
@@ -59,7 +60,7 @@ func (c *bondingCollector) Update(ch chan<- prometheus.Metric) error {
        statusfile := sysFilePath("class/net")
        bondingStats, err := readBondingStats(statusfile)
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "Not collecting bonding, file does not exist", "file", statusfile)
                        return ErrNoData
                }
@@ -86,7 +87,7 @@ func readBondingStats(root string) (status map[string][2]int, err error) {
                sstat := [2]int{0, 0}
                for _, slave := range strings.Fields(string(slaves)) {
                        state, err := ioutil.ReadFile(filepath.Join(root, master, fmt.Sprintf("lower_%s", slave), "bonding_slave", "mii_status"))
-                        if os.IsNotExist(err) {
+                        if errors.Is(err, os.ErrNotExist) {
                                // some older? kernels use slave_ prefix
                                state, err = ioutil.ReadFile(filepath.Join(root, master, fmt.Sprintf("slave_%s", slave), "bonding_slave", "mii_status"))
                        }
diff --git a/collector/btrfs_linux.go b/collector/btrfs_linux.go
index 2336e65..4d4857b 100644
--- a/collector/btrfs_linux.go
+++ b/collector/btrfs_linux.go
@@ -37,7 +37,7 @@ func init() {
 func NewBtrfsCollector(logger log.Logger) (Collector, error) {
        fs, err := btrfs.NewFS(*sysPath)
        if err != nil {
-                return nil, fmt.Errorf("failed to open sysfs: %v", err)
+                return nil, fmt.Errorf("failed to open sysfs: %w", err)
        }
        return &btrfsCollector{
@@ -51,7 +51,7 @@ func NewBtrfsCollector(logger log.Logger) (Collector, error) {
 func (c *btrfsCollector) Update(ch chan<- prometheus.Metric) error {
        stats, err := c.fs.Stats()
        if err != nil {
-                return fmt.Errorf("failed to retrieve Btrfs stats: %v", err)
+                return fmt.Errorf("failed to retrieve Btrfs stats: %w", err)
        }
        for _, s := range stats {
diff --git a/collector/buddyinfo.go b/collector/buddyinfo.go
index e94e283..579c3e4 100644
--- a/collector/buddyinfo.go
+++ b/collector/buddyinfo.go
@@ -59,7 +59,7 @@ func NewBuddyinfoCollector(logger log.Logger) (Collector, error) {
 func (c *buddyinfoCollector) Update(ch chan<- prometheus.Metric) error {
        buddyInfo, err := c.fs.BuddyInfo()
        if err != nil {
-                return fmt.Errorf("couldn't get buddyinfo: %s", err)
+                return fmt.Errorf("couldn't get buddyinfo: %w", err)
        }
        level.Debug(c.logger).Log("msg", "Set node_buddy", "buddyInfo", buddyInfo)
diff --git a/collector/diskstats_darwin.go b/collector/diskstats_darwin.go
index 89622a3..864220b 100644
--- a/collector/diskstats_darwin.go
+++ b/collector/diskstats_darwin.go
@@ -189,7 +189,7 @@ func NewDiskstatsCollector(logger log.Logger) (Collector, error) {
 func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
        diskStats, err := iostat.ReadDriveStats()
        if err != nil {
-                return fmt.Errorf("couldn't get diskstats: %s", err)
+                return fmt.Errorf("couldn't get diskstats: %w", err)
        }
        for _, stats := range diskStats {
diff --git a/collector/diskstats_linux.go b/collector/diskstats_linux.go
index 5d71422..b5ae82d 100644
--- a/collector/diskstats_linux.go
+++ b/collector/diskstats_linux.go
@@ -187,7 +187,7 @@ func NewDiskstatsCollector(logger log.Logger) (Collector, error) {
 func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
        diskStats, err := getDiskStats()
        if err != nil {
-                return fmt.Errorf("couldn't get diskstats: %s", err)
+                return fmt.Errorf("couldn't get diskstats: %w", err)
        }
        for dev, stats := range diskStats {
@@ -203,7 +203,7 @@ func (c *diskstatsCollector) Update(ch chan<- prometheus.Metric) error {
                        }
                        v, err := strconv.ParseFloat(value, 64)
                        if err != nil {
-                                return fmt.Errorf("invalid value %s in diskstats: %s", value, err)
+                                return fmt.Errorf("invalid value %s in diskstats: %w", value, err)
                        }
                        ch <- c.descs[i].mustNewConstMetric(v, dev)
                }
diff --git a/collector/drbd_linux.go b/collector/drbd_linux.go
index 6815c5f..281c079 100644
--- a/collector/drbd_linux.go
+++ b/collector/drbd_linux.go
@@ -11,10 +11,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nodrbd
 package collector
 import (
        "bufio"
+        "errors"
        "fmt"
        "os"
        "strconv"
@@ -186,7 +189,7 @@ func (c *drbdCollector) Update(ch chan<- prometheus.Metric) error {
        statsFile := procFilePath("drbd")
        file, err := os.Open(statsFile)
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "stats file does not exist, skipping", "file", statsFile, "err", err)
                        return ErrNoData
                }
diff --git a/collector/edac_linux.go b/collector/edac_linux.go
index 91b9510..1248e2e 100644
--- a/collector/edac_linux.go
+++ b/collector/edac_linux.go
@@ -86,28 +86,28 @@ func (c *edacCollector) Update(ch chan<- prometheus.Metric) error {
                value, err := readUintFromFile(filepath.Join(controller, "ce_count"))
                if err != nil {
-                        return fmt.Errorf("couldn't get ce_count for controller %s: %s", controllerNumber, err)
+                        return fmt.Errorf("couldn't get ce_count for controller %s: %w", controllerNumber, err)
                }
                ch <- prometheus.MustNewConstMetric(
                        c.ceCount, prometheus.CounterValue, float64(value), controllerNumber)
                value, err = readUintFromFile(filepath.Join(controller, "ce_noinfo_count"))
                if err != nil {
-                        return fmt.Errorf("couldn't get ce_noinfo_count for controller %s: %s", controllerNumber, err)
+                        return fmt.Errorf("couldn't get ce_noinfo_count for controller %s: %w", controllerNumber, err)
                }
                ch <- prometheus.MustNewConstMetric(
                        c.csRowCECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
                value, err = readUintFromFile(filepath.Join(controller, "ue_count"))
                if err != nil {
-                        return fmt.Errorf("couldn't get ue_count for controller %s: %s", controllerNumber, err)
+                        return fmt.Errorf("couldn't get ue_count for controller %s: %w", controllerNumber, err)
                }
                ch <- prometheus.MustNewConstMetric(
                        c.ueCount, prometheus.CounterValue, float64(value), controllerNumber)
                value, err = readUintFromFile(filepath.Join(controller, "ue_noinfo_count"))
                if err != nil {
-                        return fmt.Errorf("couldn't get ue_noinfo_count for controller %s: %s", controllerNumber, err)
+                        return fmt.Errorf("couldn't get ue_noinfo_count for controller %s: %w", controllerNumber, err)
                }
                ch <- prometheus.MustNewConstMetric(
                        c.csRowUECount, prometheus.CounterValue, float64(value), controllerNumber, "unknown")
@@ -126,14 +126,14 @@ func (c *edacCollector) Update(ch chan<- prometheus.Metric) error {
                        value, err = readUintFromFile(filepath.Join(csrow, "ce_count"))
                        if err != nil {
-                                return fmt.Errorf("couldn't get ce_count for controller/csrow %s/%s: %s", controllerNumber, csrowNumber, err)
+                                return fmt.Errorf("couldn't get ce_count for controller/csrow %s/%s: %w", controllerNumber, csrowNumber, err)
                        }
                        ch <- prometheus.MustNewConstMetric(
                                c.csRowCECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
                        value, err = readUintFromFile(filepath.Join(csrow, "ue_count"))
                        if err != nil {
-                                return fmt.Errorf("couldn't get ue_count for controller/csrow %s/%s: %s", controllerNumber, csrowNumber, err)
+                                return fmt.Errorf("couldn't get ue_count for controller/csrow %s/%s: %w", controllerNumber, csrowNumber, err)
                        }
                        ch <- prometheus.MustNewConstMetric(
                                c.csRowUECount, prometheus.CounterValue, float64(value), controllerNumber, csrowNumber)
diff --git a/collector/entropy_linux.go b/collector/entropy_linux.go
index e68eb95..3c42c3d 100644
--- a/collector/entropy_linux.go
+++ b/collector/entropy_linux.go
@@ -46,7 +46,7 @@ func NewEntropyCollector(logger log.Logger) (Collector, error) {
 func (c *entropyCollector) Update(ch chan<- prometheus.Metric) error {
        value, err := readUintFromFile(procFilePath("sys/kernel/random/entropy_avail"))
        if err != nil {
-                return fmt.Errorf("couldn't get entropy_avail: %s", err)
+                return fmt.Errorf("couldn't get entropy_avail: %w", err)
        }
        ch <- prometheus.MustNewConstMetric(
                c.entropyAvail, prometheus.GaugeValue, float64(value))
diff --git a/collector/filefd_linux.go b/collector/filefd_linux.go
index f8d3fce..450c4e3 100644
--- a/collector/filefd_linux.go
+++ b/collector/filefd_linux.go
@@ -46,12 +46,12 @@ func NewFileFDStatCollector(logger log.Logger) (Collector, error) {
 func (c *fileFDStatCollector) Update(ch chan<- prometheus.Metric) error {
        fileFDStat, err := parseFileFDStats(procFilePath("sys/fs/file-nr"))
        if err != nil {
-                return fmt.Errorf("couldn't get file-nr: %s", err)
+                return fmt.Errorf("couldn't get file-nr: %w", err)
        }
        for name, value := range fileFDStat {
                v, err := strconv.ParseFloat(value, 64)
                if err != nil {
-                        return fmt.Errorf("invalid value %s in file-nr: %s", value, err)
+                        return fmt.Errorf("invalid value %s in file-nr: %w", value, err)
                }
                ch <- prometheus.MustNewConstMetric(
                        prometheus.NewDesc(
diff --git a/collector/filesystem_common.go b/collector/filesystem_common.go
index 6971f44..7def2b9 100644
--- a/collector/filesystem_common.go
+++ b/collector/filesystem_common.go
@@ -20,6 +20,7 @@ import (
        "regexp"
        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
        "github.com/prometheus/client_golang/prometheus"
        "gopkg.in/alecthomas/kingpin.v2"
 )
@@ -70,7 +71,9 @@ func init() {
 // NewFilesystemCollector returns a new Collector exposing filesystems stats.
 func NewFilesystemCollector(logger log.Logger) (Collector, error) {
        subsystem := "filesystem"
+        level.Info(logger).Log("msg", "Parsed flag --collector.filesystem.ignored-mount-points", "flag", *ignoredMountPoints)
        mountPointPattern := regexp.MustCompile(*ignoredMountPoints)
+        level.Info(logger).Log("msg", "Parsed flag --collector.filesystem.ignored-fs-types", "flag", *ignoredMountPoints)
        filesystemsTypesPattern := regexp.MustCompile(*ignoredFSTypes)
        sizeDesc := prometheus.NewDesc(
diff --git a/collector/filesystem_freebsd.go b/collector/filesystem_freebsd.go
index f37029e..1d377b1 100644
--- a/collector/filesystem_freebsd.go
+++ b/collector/filesystem_freebsd.go
@@ -40,14 +40,14 @@ func (c *filesystemCollector) GetStats() ([]filesystemStats, error) {
        }
        stats := []filesystemStats{}
        for _, fs := range buf {
-                mountpoint := string(fs.Mntonname[:])
+                mountpoint := bytesToString(fs.Mntonname[:])
                if c.ignoredMountPointsPattern.MatchString(mountpoint) {
                        level.Debug(c.logger).Log("msg", "Ignoring mount point", "mountpoint", mountpoint)
                        continue
                }
-                device := string(fs.Mntfromname[:])
+                device := bytesToString(fs.Mntfromname[:])
-                fstype := string(fs.Fstypename[:])
+                fstype := bytesToString(fs.Fstypename[:])
                if c.ignoredFSTypesPattern.MatchString(fstype) {
                        level.Debug(c.logger).Log("msg", "Ignoring fs type", "type", fstype)
                        continue
diff --git a/collector/filesystem_linux.go b/collector/filesystem_linux.go
index e83b27a..00a7323 100644
--- a/collector/filesystem_linux.go
+++ b/collector/filesystem_linux.go
@@ -17,6 +17,7 @@ package collector
 import (
        "bufio"
+        "errors"
        "fmt"
        "io"
        "os"
@@ -139,7 +140,7 @@ func stuckMountWatcher(mountPoint string, success chan struct{}, logger log.Logg
 func mountPointDetails(logger log.Logger) ([]filesystemLabels, error) {
        file, err := os.Open(procFilePath("1/mounts"))
-        if os.IsNotExist(err) {
+        if errors.Is(err, os.ErrNotExist) {
                // Fallback to `/proc/mounts` if `/proc/1/mounts` is missing due hidepid.
                level.Debug(logger).Log("msg", "Reading root mounts failed, falling back to system mounts", "err", err)
                file, err = os.Open(procFilePath("mounts"))
diff --git a/collector/filesystem_linux_test.go b/collector/filesystem_linux_test.go
index 973cd14..e401779 100644
--- a/collector/filesystem_linux_test.go
+++ b/collector/filesystem_linux_test.go
@@ -11,8 +11,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// +build !nofilesystem
 package collector
 import (
diff --git a/collector/fixtures/e2e-64k-page-output.txt b/collector/fixtures/e2e-64k-page-output.txt
index 6c9473f..7b857ff 100644
--- a/collector/fixtures/e2e-64k-page-output.txt
+++ b/collector/fixtures/e2e-64k-page-output.txt
@@ -1886,6 +1886,9 @@ node_netstat_Tcp_InErrs 5
 # HELP node_netstat_Tcp_InSegs Statistic TcpInSegs.
 # TYPE node_netstat_Tcp_InSegs untyped
 node_netstat_Tcp_InSegs 5.7252008e+07
+# HELP node_netstat_Tcp_OutRsts Statistic TcpOutRsts.
+# TYPE node_netstat_Tcp_OutRsts untyped
+node_netstat_Tcp_OutRsts 1003
 # HELP node_netstat_Tcp_OutSegs Statistic TcpOutSegs.
 # TYPE node_netstat_Tcp_OutSegs untyped
 node_netstat_Tcp_OutSegs 5.4915039e+07
diff --git a/collector/fixtures/e2e-output.txt b/collector/fixtures/e2e-output.txt
index af9925b..e8a5779 100644
--- a/collector/fixtures/e2e-output.txt
+++ b/collector/fixtures/e2e-output.txt
@@ -1955,6 +1955,9 @@ node_netstat_Tcp_InErrs 5
 # HELP node_netstat_Tcp_InSegs Statistic TcpInSegs.
 # TYPE node_netstat_Tcp_InSegs untyped
 node_netstat_Tcp_InSegs 5.7252008e+07
+# HELP node_netstat_Tcp_OutRsts Statistic TcpOutRsts.
+# TYPE node_netstat_Tcp_OutRsts untyped
+node_netstat_Tcp_OutRsts 1003
 # HELP node_netstat_Tcp_OutSegs Statistic TcpOutSegs.
 # TYPE node_netstat_Tcp_OutSegs untyped
 node_netstat_Tcp_OutSegs 5.4915039e+07
diff --git a/collector/fixtures/sys.ttar b/collector/fixtures/sys.ttar
index a4550a5..3e52c60 100644
--- a/collector/fixtures/sys.ttar
+++ b/collector/fixtures/sys.ttar
@@ -1756,6 +1756,17 @@ Lines: 1
 0
 Mode: 644
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: sys/devices/pci0000:00/0000:00:0d.0/ata4/host3/target3:0:0/3:0:0:0/block/sdb/bcache/writeback_rate_debug
+Lines: 7
+rate:           1.1M/sec
+dirty:          20.4G
+target:         20.4G
+proportional:   427.5k
+integral:       790.0k
+change:         321.5k/sec
+next io:        17ms
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: sys/devices/pci0000:00/0000:00:0d.0/ata5
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
diff --git a/collector/helper.go b/collector/helper.go
index 2bf461e..df5cd26 100644
--- a/collector/helper.go
+++ b/collector/helper.go
@@ -14,6 +14,7 @@
 package collector
 import (
+        "bytes"
        "io/ioutil"
        "strconv"
        "strings"
@@ -30,3 +31,16 @@ func readUintFromFile(path string) (uint64, error) {
        }
        return value, nil
 }
+// Take a []byte{} and return a string based on null termination.
+// This is useful for situations where the OS has returned a null terminated
+// string to use.
+// If this function happens to receive a byteArray that contains no nulls, we
+// simply convert the array to a string with no bounding.
+func bytesToString(byteArray []byte) string {
+        n := bytes.IndexByte(byteArray, 0)
+        if n < 0 {
+                return string(byteArray)
+        }
+        return string(byteArray[:n])
+}
diff --git a/collector/helper_test.go b/collector/helper_test.go
new file mode 100644
index 0000000..0424d48
--- /dev/null
+++ b/collector/helper_test.go
@@ -0,0 +1,63 @@
+// Copyright 2020 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 collector
+import (
+        "testing"
+)
+func TestBytesToString(t *testing.T) {
+        tests := []struct {
+                name     string
+                b        []byte
+                expected string
+        }{
+                {
+                        "Single null byte",
+                        []byte{0},
+                        "",
+                },
+                {
+                        "Empty byte array",
+                        []byte{},
+                        "",
+                },
+                {
+                        "Not null terminated",
+                        []byte{65, 66, 67},
+                        "ABC",
+                },
+                {
+                        "Null randomly in array",
+                        []byte{65, 66, 67, 0, 65, 0, 65},
+                        "ABC",
+                },
+                {
+                        "Array starts with null and contains other valid bytes",
+                        []byte{0, 65, 66, 67, 0},
+                        "",
+                },
+        }
+        for _, tt := range tests {
+                name := tt.name
+                b := tt.b
+                result := bytesToString(b)
+                expected := tt.expected
+                if result != expected {
+                        t.Errorf("bytesToString(%#v): Name: %s, expected %#v, got %#v)", b, name, expected, result)
+                }
+        }
+}
diff --git a/collector/hwmon_linux.go b/collector/hwmon_linux.go
index 5649942..261a7c5 100644
--- a/collector/hwmon_linux.go
+++ b/collector/hwmon_linux.go
@@ -424,7 +424,7 @@ func (c *hwMonCollector) Update(ch chan<- prometheus.Metric) error {
        hwmonFiles, err := ioutil.ReadDir(hwmonPathName)
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "hwmon collector metrics are not available for this system")
                        return ErrNoData
                }
diff --git a/collector/infiniband_linux.go b/collector/infiniband_linux.go
index 1f453b8..d938210 100644
--- a/collector/infiniband_linux.go
+++ b/collector/infiniband_linux.go
@@ -17,6 +17,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
        "strconv"
@@ -108,11 +109,11 @@ func (c *infinibandCollector) pushCounter(ch chan<- prometheus.Metric, name stri
 func (c *infinibandCollector) Update(ch chan<- prometheus.Metric) error {
        devices, err := c.fs.InfiniBandClass()
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "infiniband statistics not found, skipping")
                        return ErrNoData
                }
-                return fmt.Errorf("error obtaining InfiniBand class info: %s", err)
+                return fmt.Errorf("error obtaining InfiniBand class info: %w", err)
        }
        for _, device := range devices {
diff --git a/collector/interrupts_linux.go b/collector/interrupts_linux.go
index cacfeda..5fcbebc 100644
--- a/collector/interrupts_linux.go
+++ b/collector/interrupts_linux.go
@@ -34,13 +34,13 @@ var (
 func (c *interruptsCollector) Update(ch chan<- prometheus.Metric) (err error) {
        interrupts, err := getInterrupts()
        if err != nil {
-                return fmt.Errorf("couldn't get interrupts: %s", err)
+                return fmt.Errorf("couldn't get interrupts: %w", err)
        }
        for name, interrupt := range interrupts {
                for cpuNo, value := range interrupt.values {
                        fv, err := strconv.ParseFloat(value, 64)
                        if err != nil {
-                                return fmt.Errorf("invalid value %s in interrupts: %s", value, err)
+                                return fmt.Errorf("invalid value %s in interrupts: %w", value, err)
                        }
                        ch <- c.desc.mustNewConstMetric(fv, strconv.Itoa(cpuNo), name, interrupt.info, interrupt.devices)
                }
diff --git a/collector/interrupts_openbsd.go b/collector/interrupts_openbsd.go
index c9aae3c..bf38fe3 100644
--- a/collector/interrupts_openbsd.go
+++ b/collector/interrupts_openbsd.go
@@ -101,7 +101,7 @@ var (
 func (c *interruptsCollector) Update(ch chan<- prometheus.Metric) error {
        interrupts, err := getInterrupts()
        if err != nil {
-                return fmt.Errorf("couldn't get interrupts: %s", err)
+                return fmt.Errorf("couldn't get interrupts: %w", err)
        }
        for dev, interrupt := range interrupts {
                for cpuNo, value := range interrupt.values {
diff --git a/collector/ipvs_linux.go b/collector/ipvs_linux.go
index b5c8d73..c2e9d70 100644
--- a/collector/ipvs_linux.go
+++ b/collector/ipvs_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
        "sort"
@@ -140,11 +141,11 @@ func (c *ipvsCollector) Update(ch chan<- prometheus.Metric) error {
        ipvsStats, err := c.fs.IPVSStats()
        if err != nil {
                // Cannot access ipvs metrics, report no error.
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "ipvs collector metrics are not available for this system")
                        return ErrNoData
                }
-                return fmt.Errorf("could not get IPVS stats: %s", err)
+                return fmt.Errorf("could not get IPVS stats: %w", err)
        }
        ch <- c.connections.mustNewConstMetric(float64(ipvsStats.Connections))
        ch <- c.incomingPackets.mustNewConstMetric(float64(ipvsStats.IncomingPackets))
@@ -154,7 +155,7 @@ func (c *ipvsCollector) Update(ch chan<- prometheus.Metric) error {
        backendStats, err := c.fs.IPVSBackendStatus()
        if err != nil {
-                return fmt.Errorf("could not get backend status: %s", err)
+                return fmt.Errorf("could not get backend status: %w", err)
        }
        sums := map[string]ipvsBackendStatus{}
diff --git a/collector/kvm_bsd.go b/collector/kvm_bsd.go
index b4e95e6..8798736 100644
--- a/collector/kvm_bsd.go
+++ b/collector/kvm_bsd.go
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// +build !nomeminfo
+// +build !nokvm
 // +build freebsd dragonfly
 package collector
diff --git a/collector/loadavg.go b/collector/loadavg.go
index 7c8bcff..7c1fd99 100644
--- a/collector/loadavg.go
+++ b/collector/loadavg.go
@@ -48,7 +48,7 @@ func NewLoadavgCollector(logger log.Logger) (Collector, error) {
 func (c *loadavgCollector) Update(ch chan<- prometheus.Metric) error {
        loads, err := getLoad()
        if err != nil {
-                return fmt.Errorf("couldn't get load: %s", err)
+                return fmt.Errorf("couldn't get load: %w", err)
        }
        for i, load := range loads {
                level.Debug(c.logger).Log("msg", "return load", "index", i, "load", load)
diff --git a/collector/loadavg_linux.go b/collector/loadavg_linux.go
index 668d3ed..7b89668 100644
--- a/collector/loadavg_linux.go
+++ b/collector/loadavg_linux.go
@@ -45,7 +45,7 @@ func parseLoad(data string) (loads []float64, err error) {
        for i, load := range parts[0:3] {
                loads[i], err = strconv.ParseFloat(load, 64)
                if err != nil {
-                        return nil, fmt.Errorf("could not parse load '%s': %s", load, err)
+                        return nil, fmt.Errorf("could not parse load '%s': %w", load, err)
                }
        }
        return loads, nil
diff --git a/collector/logind_linux.go b/collector/logind_linux.go
index fb3cb57..19a29a2 100644
--- a/collector/logind_linux.go
+++ b/collector/logind_linux.go
@@ -92,7 +92,7 @@ func NewLogindCollector(logger log.Logger) (Collector, error) {
 func (lc *logindCollector) Update(ch chan<- prometheus.Metric) error {
        c, err := newDbus()
        if err != nil {
-                return fmt.Errorf("unable to connect to dbus: %s", err)
+                return fmt.Errorf("unable to connect to dbus: %w", err)
        }
        defer c.conn.Close()
@@ -102,12 +102,12 @@ func (lc *logindCollector) Update(ch chan<- prometheus.Metric) error {
 func collectMetrics(ch chan<- prometheus.Metric, c logindInterface) error {
        seats, err := c.listSeats()
        if err != nil {
-                return fmt.Errorf("unable to get seats: %s", err)
+                return fmt.Errorf("unable to get seats: %w", err)
        }
        sessionList, err := c.listSessions()
        if err != nil {
-                return fmt.Errorf("unable to get sessions: %s", err)
+                return fmt.Errorf("unable to get sessions: %w", err)
        }
        sessions := make(map[logindSession]float64)
diff --git a/collector/mdadm_linux.go b/collector/mdadm_linux.go
index 05f83ee..865553f 100644
--- a/collector/mdadm_linux.go
+++ b/collector/mdadm_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -94,21 +95,21 @@ var (
 )
 func (c *mdadmCollector) Update(ch chan<- prometheus.Metric) error {
-        fs, errFs := procfs.NewFS(*procPath)
+        fs, err := procfs.NewFS(*procPath)
-        if errFs != nil {
+        if err != nil {
-                return fmt.Errorf("failed to open procfs: %w", errFs)
+                return fmt.Errorf("failed to open procfs: %w", err)
        }
        mdStats, err := fs.MDStat()
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "Not collecting mdstat, file does not exist", "file", *procPath)
                        return ErrNoData
                }
-                return fmt.Errorf("error parsing mdstatus: %s", err)
+                return fmt.Errorf("error parsing mdstatus: %w", err)
        }
        for _, mdStat := range mdStats {
diff --git a/collector/meminfo.go b/collector/meminfo.go
index d3d3b8d..38b2326 100644
--- a/collector/meminfo.go
+++ b/collector/meminfo.go
@@ -48,7 +48,7 @@ func (c *meminfoCollector) Update(ch chan<- prometheus.Metric) error {
        var metricType prometheus.ValueType
        memInfo, err := c.getMemInfo()
        if err != nil {
-                return fmt.Errorf("couldn't get meminfo: %s", err)
+                return fmt.Errorf("couldn't get meminfo: %w", err)
        }
        level.Debug(c.logger).Log("msg", "Set node_mem", "memInfo", memInfo)
        for k, v := range memInfo {
diff --git a/collector/meminfo_linux.go b/collector/meminfo_linux.go
index 3b9e2e9..88505da 100644
--- a/collector/meminfo_linux.go
+++ b/collector/meminfo_linux.go
@@ -54,7 +54,7 @@ func parseMemInfo(r io.Reader) (map[string]float64, error) {
                }
                fv, err := strconv.ParseFloat(parts[1], 64)
                if err != nil {
-                        return nil, fmt.Errorf("invalid value in meminfo: %s", err)
+                        return nil, fmt.Errorf("invalid value in meminfo: %w", err)
                }
                key := parts[0][:len(parts[0])-1] // remove trailing : from key
                // Active(anon) -> Active_anon
diff --git a/collector/meminfo_numa_linux.go b/collector/meminfo_numa_linux.go
index d36f6a0..f3d9307 100644
--- a/collector/meminfo_numa_linux.go
+++ b/collector/meminfo_numa_linux.go
@@ -62,7 +62,7 @@ func NewMeminfoNumaCollector(logger log.Logger) (Collector, error) {
 func (c *meminfoNumaCollector) Update(ch chan<- prometheus.Metric) error {
        metrics, err := getMemInfoNuma()
        if err != nil {
-                return fmt.Errorf("couldn't get NUMA meminfo: %s", err)
+                return fmt.Errorf("couldn't get NUMA meminfo: %w", err)
        }
        for _, v := range metrics {
                desc, ok := c.metricDescs[v.metricName]
@@ -137,7 +137,7 @@ func parseMemInfoNuma(r io.Reader) ([]meminfoMetric, error) {
                fv, err := strconv.ParseFloat(parts[3], 64)
                if err != nil {
-                        return nil, fmt.Errorf("invalid value in meminfo: %s", err)
+                        return nil, fmt.Errorf("invalid value in meminfo: %w", err)
                }
                switch l := len(parts); {
                case l == 4: // no unit
@@ -174,7 +174,7 @@ func parseMemInfoNumaStat(r io.Reader, nodeNumber string) ([]meminfoMetric, erro
                fv, err := strconv.ParseFloat(parts[1], 64)
                if err != nil {
-                        return nil, fmt.Errorf("invalid value in numastat: %s", err)
+                        return nil, fmt.Errorf("invalid value in numastat: %w", err)
                }
                numaStat = append(numaStat, meminfoMetric{parts[0] + "_total", prometheus.CounterValue, nodeNumber, fv})
diff --git a/collector/meminfo_openbsd.go b/collector/meminfo_openbsd.go
index 073fbe7..81102d5 100644
--- a/collector/meminfo_openbsd.go
+++ b/collector/meminfo_openbsd.go
@@ -62,7 +62,7 @@ func (c *meminfoCollector) getMemInfo() (map[string]float64, error) {
        }
        if _, err := C.sysctl_bcstats(&bcstats); err != nil {
-                return nil, fmt.Errorf("sysctl CTL_VFS VFS_GENERIC VFS_BCACHESTAT failed: %v", err)
+                return nil, fmt.Errorf("sysctl CTL_VFS VFS_GENERIC VFS_BCACHESTAT failed: %w", err)
        }
        ps := float64(uvmexp.pagesize)
diff --git a/collector/memory_bsd.go b/collector/memory_bsd.go
index 4be5ddd..ac8b301 100644
--- a/collector/memory_bsd.go
+++ b/collector/memory_bsd.go
@@ -43,7 +43,7 @@ func init() {
 func NewMemoryCollector(logger log.Logger) (Collector, error) {
        tmp32, err := unix.SysctlUint32("vm.stats.vm.v_page_size")
        if err != nil {
-                return nil, fmt.Errorf("sysctl(vm.stats.vm.v_page_size) failed: %s", err)
+                return nil, fmt.Errorf("sysctl(vm.stats.vm.v_page_size) failed: %w", err)
        }
        size := float64(tmp32)
@@ -136,7 +136,7 @@ func (c *memoryCollector) Update(ch chan<- prometheus.Metric) error {
        for _, m := range c.sysctls {
                v, err := m.Value()
                if err != nil {
-                        return fmt.Errorf("couldn't get memory: %s", err)
+                        return fmt.Errorf("couldn't get memory: %w", err)
                }
                // Most are gauges.
@@ -154,7 +154,7 @@ func (c *memoryCollector) Update(ch chan<- prometheus.Metric) error {
        swapUsed, err := c.kvm.SwapUsedPages()
        if err != nil {
-                return fmt.Errorf("couldn't get kvm: %s", err)
+                return fmt.Errorf("couldn't get kvm: %w", err)
        }
        ch <- prometheus.MustNewConstMetric(
diff --git a/collector/mountstats_linux.go b/collector/mountstats_linux.go
index 3fa1597..4102067 100644
--- a/collector/mountstats_linux.go
+++ b/collector/mountstats_linux.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nomountstats
 package collector
 import (
diff --git a/collector/netclass_linux.go b/collector/netclass_linux.go
index cbfcb62..0fde219 100644
--- a/collector/netclass_linux.go
+++ b/collector/netclass_linux.go
@@ -61,7 +61,7 @@ func NewNetClassCollector(logger log.Logger) (Collector, error) {
 func (c *netClassCollector) Update(ch chan<- prometheus.Metric) error {
        netClass, err := c.getNetClassInfo()
        if err != nil {
-                return fmt.Errorf("could not get net class info: %s", err)
+                return fmt.Errorf("could not get net class info: %w", err)
        }
        for _, ifaceInfo := range netClass {
                upDesc := prometheus.NewDesc(
@@ -175,7 +175,7 @@ func (c *netClassCollector) getNetClassInfo() (sysfs.NetClass, error) {
        netClass, err := c.fs.NetClass()
        if err != nil {
-                return netClass, fmt.Errorf("error obtaining net class info: %s", err)
+                return netClass, fmt.Errorf("error obtaining net class info: %w", err)
        }
        for device := range netClass {
diff --git a/collector/netdev_common.go b/collector/netdev_common.go
index 2164469..a28bd43 100644
--- a/collector/netdev_common.go
+++ b/collector/netdev_common.go
@@ -23,21 +23,24 @@ import (
        "strconv"
        "github.com/go-kit/kit/log"
+        "github.com/go-kit/kit/log/level"
        "github.com/prometheus/client_golang/prometheus"
        "gopkg.in/alecthomas/kingpin.v2"
 )
 var (
-        netdevIgnoredDevices = kingpin.Flag("collector.netdev.device-blacklist", "Regexp of net devices to blacklist (mutually exclusive to device-whitelist).").String()
+        netdevDeviceInclude    = kingpin.Flag("collector.netdev.device-include", "Regexp of net devices to include (mutually exclusive to device-exclude).").String()
-        netdevAcceptDevices  = kingpin.Flag("collector.netdev.device-whitelist", "Regexp of net devices to whitelist (mutually exclusive to device-blacklist).").String()
+        oldNetdevDeviceInclude = kingpin.Flag("collector.netdev.device-whitelist", "DEPRECATED: Use collector.netdev.device-include").Hidden().String()
+        netdevDeviceExclude    = kingpin.Flag("collector.netdev.device-exclude", "Regexp of net devices to exclude (mutually exclusive to device-include).").String()
+        oldNetdevDeviceExclude = kingpin.Flag("collector.netdev.device-blacklist", "DEPRECATED: Use collector.netdev.device-exclude").Hidden().String()
 )
 type netDevCollector struct {
-        subsystem             string
+        subsystem            string
-        ignoredDevicesPattern *regexp.Regexp
+        deviceExcludePattern *regexp.Regexp
-        acceptDevicesPattern  *regexp.Regexp
+        deviceIncludePattern *regexp.Regexp
-        metricDescs           map[string]*prometheus.Desc
+        metricDescs          map[string]*prometheus.Desc
-        logger                log.Logger
+        logger               log.Logger
 }
 func init() {
@@ -46,33 +49,53 @@ func init() {
 // NewNetDevCollector returns a new Collector exposing network device stats.
 func NewNetDevCollector(logger log.Logger) (Collector, error) {
-        if *netdevIgnoredDevices != "" && *netdevAcceptDevices != "" {
+        if *oldNetdevDeviceInclude != "" {
-                return nil, errors.New("device-blacklist & accept-devices are mutually exclusive")
+                if *netdevDeviceInclude == "" {
+                        level.Warn(logger).Log("msg", "--collector.netdev.device-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-include")
+                        *netdevDeviceInclude = *oldNetdevDeviceInclude
+                } else {
+                        return nil, errors.New("--collector.netdev.device-whitelist and --collector.netdev.device-include are mutually exclusive")
+                }
+        }
+        if *oldNetdevDeviceExclude != "" {
+                if *netdevDeviceExclude == "" {
+                        level.Warn(logger).Log("msg", "--collector.netdev.device-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.netdev.device-exclude")
+                        *netdevDeviceExclude = *oldNetdevDeviceExclude
+                } else {
+                        return nil, errors.New("--collector.netdev.device-blacklist and --collector.netdev.device-exclude are mutually exclusive")
+                }
+        }
+        if *netdevDeviceExclude != "" && *netdevDeviceInclude != "" {
+                return nil, errors.New("device-exclude & device-include are mutually exclusive")
        }
-        var ignorePattern *regexp.Regexp
+        var excludePattern *regexp.Regexp
-        if *netdevIgnoredDevices != "" {
+        if *netdevDeviceExclude != "" {
-                ignorePattern = regexp.MustCompile(*netdevIgnoredDevices)
+                level.Info(logger).Log("msg", "Parsed flag --collector.netdev.device-exclude", "flag", *netdevDeviceExclude)
+                excludePattern = regexp.MustCompile(*netdevDeviceExclude)
        }
-        var acceptPattern *regexp.Regexp
+        var includePattern *regexp.Regexp
-        if *netdevAcceptDevices != "" {
+        if *netdevDeviceInclude != "" {
-                acceptPattern = regexp.MustCompile(*netdevAcceptDevices)
+                level.Info(logger).Log("msg", "Parsed Flag --collector.netdev.device-include", "flag", *netdevDeviceInclude)
+                includePattern = regexp.MustCompile(*netdevDeviceInclude)
        }
        return &netDevCollector{
-                subsystem:             "network",
+                subsystem:            "network",
-                ignoredDevicesPattern: ignorePattern,
+                deviceExcludePattern: excludePattern,
-                acceptDevicesPattern:  acceptPattern,
+                deviceIncludePattern: includePattern,
-                metricDescs:           map[string]*prometheus.Desc{},
+                metricDescs:          map[string]*prometheus.Desc{},
-                logger:                logger,
+                logger:               logger,
        }, nil
 }
 func (c *netDevCollector) Update(ch chan<- prometheus.Metric) error {
-        netDev, err := getNetDevStats(c.ignoredDevicesPattern, c.acceptDevicesPattern, c.logger)
+        netDev, err := getNetDevStats(c.deviceExcludePattern, c.deviceIncludePattern, c.logger)
        if err != nil {
-                return fmt.Errorf("couldn't get netstats: %s", err)
+                return fmt.Errorf("couldn't get netstats: %w", err)
        }
        for dev, devStats := range netDev {
                for key, value := range devStats {
@@ -88,7 +111,7 @@ func (c *netDevCollector) Update(ch chan<- prometheus.Metric) error {
                        }
                        v, err := strconv.ParseFloat(value, 64)
                        if err != nil {
-                                return fmt.Errorf("invalid value %s in netstats: %s", value, err)
+                                return fmt.Errorf("invalid value %s in netstats: %w", value, err)
                        }
                        ch <- prometheus.MustNewConstMetric(desc, prometheus.CounterValue, v, dev)
                }
diff --git a/collector/netstat_linux.go b/collector/netstat_linux.go
index 9b4be49..98447f8 100644
--- a/collector/netstat_linux.go
+++ b/collector/netstat_linux.go
@@ -17,6 +17,7 @@ package collector
 import (
        "bufio"
+        "errors"
        "fmt"
        "io"
        "os"
@@ -34,7 +35,7 @@ const (
 )
 var (
-        netStatFields = kingpin.Flag("collector.netstat.fields", "Regexp of fields to return for netstat collector.").Default("^(.*_(InErrors|InErrs)|Ip_Forwarding|Ip(6|Ext)_(InOctets|OutOctets)|Icmp6?_(InMsgs|OutMsgs)|TcpExt_(Listen.*|Syncookies.*|TCPSynRetrans)|Tcp_(ActiveOpens|InSegs|OutSegs|PassiveOpens|RetransSegs|CurrEstab)|Udp6?_(InDatagrams|OutDatagrams|NoPorts|RcvbufErrors|SndbufErrors))$").String()
+        netStatFields = kingpin.Flag("collector.netstat.fields", "Regexp of fields to return for netstat collector.").Default("^(.*_(InErrors|InErrs)|Ip_Forwarding|Ip(6|Ext)_(InOctets|OutOctets)|Icmp6?_(InMsgs|OutMsgs)|TcpExt_(Listen.*|Syncookies.*|TCPSynRetrans)|Tcp_(ActiveOpens|InSegs|OutSegs|OutRsts|PassiveOpens|RetransSegs|CurrEstab)|Udp6?_(InDatagrams|OutDatagrams|NoPorts|RcvbufErrors|SndbufErrors))$").String()
 )
 type netStatCollector struct {
@@ -59,15 +60,15 @@ func NewNetStatCollector(logger log.Logger) (Collector, error) {
 func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error {
        netStats, err := getNetStats(procFilePath("net/netstat"))
        if err != nil {
-                return fmt.Errorf("couldn't get netstats: %s", err)
+                return fmt.Errorf("couldn't get netstats: %w", err)
        }
        snmpStats, err := getNetStats(procFilePath("net/snmp"))
        if err != nil {
-                return fmt.Errorf("couldn't get SNMP stats: %s", err)
+                return fmt.Errorf("couldn't get SNMP stats: %w", err)
        }
        snmp6Stats, err := getSNMP6Stats(procFilePath("net/snmp6"))
        if err != nil {
-                return fmt.Errorf("couldn't get SNMP6 stats: %s", err)
+                return fmt.Errorf("couldn't get SNMP6 stats: %w", err)
        }
        // Merge the results of snmpStats into netStats (collisions are possible, but
        // we know that the keys are always unique for the given use case).
@@ -82,7 +83,7 @@ func (c *netStatCollector) Update(ch chan<- prometheus.Metric) error {
                        key := protocol + "_" + name
                        v, err := strconv.ParseFloat(value, 64)
                        if err != nil {
-                                return fmt.Errorf("invalid value %s in netstats: %s", value, err)
+                                return fmt.Errorf("invalid value %s in netstats: %w", value, err)
                        }
                        if !c.fieldPattern.MatchString(key) {
                                continue
@@ -140,7 +141,7 @@ func getSNMP6Stats(fileName string) (map[string]map[string]string, error) {
        if err != nil {
                // On systems with IPv6 disabled, this file won't exist.
                // Do nothing.
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        return nil, nil
                }
diff --git a/collector/nfs_linux.go b/collector/nfs_linux.go
index 55f9e19..60803eb 100644
--- a/collector/nfs_linux.go
+++ b/collector/nfs_linux.go
@@ -11,9 +11,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nonfs
 package collector
 import (
+        "errors"
        "fmt"
        "os"
        "reflect"
@@ -95,7 +98,7 @@ func NewNfsCollector(logger log.Logger) (Collector, error) {
 func (c *nfsCollector) Update(ch chan<- prometheus.Metric) error {
        stats, err := c.fs.ClientRPCStats()
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "Not collecting NFS metrics", "err", err)
                        return ErrNoData
                }
diff --git a/collector/nfsd_linux.go b/collector/nfsd_linux.go
index b6f2f8e..3dba899 100644
--- a/collector/nfsd_linux.go
+++ b/collector/nfsd_linux.go
@@ -11,9 +11,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nonfsd
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -61,7 +64,7 @@ func NewNFSdCollector(logger log.Logger) (Collector, error) {
 func (c *nfsdCollector) Update(ch chan<- prometheus.Metric) error {
        stats, err := c.fs.ServerRPCStats()
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "Not collecting NFSd metrics", "err", err)
                        return ErrNoData
                }
diff --git a/collector/ntp.go b/collector/ntp.go
index 411ba25..c7d55c9 100644
--- a/collector/ntp.go
+++ b/collector/ntp.go
@@ -125,7 +125,7 @@ func (c *ntpCollector) Update(ch chan<- prometheus.Metric) error {
                Timeout: time.Second, // default `ntpdate` timeout
        })
        if err != nil {
-                return fmt.Errorf("couldn't get SNTP reply: %s", err)
+                return fmt.Errorf("couldn't get SNTP reply: %w", err)
        }
        ch <- c.stratum.mustNewConstMetric(float64(resp.Stratum))
diff --git a/collector/perf_linux.go b/collector/perf_linux.go
index e452754..3a2f739 100644
--- a/collector/perf_linux.go
+++ b/collector/perf_linux.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !noperf
 package collector
 import (
diff --git a/collector/powersupplyclass.go b/collector/powersupplyclass.go
index 988b0ee..adebf0e 100644
--- a/collector/powersupplyclass.go
+++ b/collector/powersupplyclass.go
@@ -17,7 +17,9 @@
 package collector
 import (
+        "errors"
        "fmt"
+        "os"
        "regexp"
        "github.com/go-kit/kit/log"
@@ -54,7 +56,10 @@ func NewPowerSupplyClassCollector(logger log.Logger) (Collector, error) {
 func (c *powerSupplyClassCollector) Update(ch chan<- prometheus.Metric) error {
        powerSupplyClass, err := getPowerSupplyClassInfo(c.ignoredPattern)
        if err != nil {
-                return fmt.Errorf("could not get power_supply class info: %s", err)
+                if errors.Is(err, os.ErrNotExist) {
+                        return ErrNoData
+                }
+                return fmt.Errorf("could not get power_supply class info: %w", err)
        }
        for _, powerSupply := range powerSupplyClass {
@@ -184,7 +189,7 @@ func getPowerSupplyClassInfo(ignore *regexp.Regexp) (sysfs.PowerSupplyClass, err
        powerSupplyClass, err := fs.PowerSupplyClass()
        if err != nil {
-                return powerSupplyClass, fmt.Errorf("error obtaining power_supply class info: %s", err)
+                return powerSupplyClass, fmt.Errorf("error obtaining power_supply class info: %w", err)
        }
        for device := range powerSupplyClass {
diff --git a/collector/processes_linux.go b/collector/processes_linux.go
index 3d64cbd..3d4e95d 100644
--- a/collector/processes_linux.go
+++ b/collector/processes_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -75,13 +76,13 @@ func NewProcessStatCollector(logger log.Logger) (Collector, error) {
 func (c *processCollector) Update(ch chan<- prometheus.Metric) error {
        pids, states, threads, err := c.getAllocatedThreads()
        if err != nil {
-                return fmt.Errorf("unable to retrieve number of allocated threads: %q", err)
+                return fmt.Errorf("unable to retrieve number of allocated threads: %w", err)
        }
        ch <- prometheus.MustNewConstMetric(c.threadAlloc, prometheus.GaugeValue, float64(threads))
        maxThreads, err := readUintFromFile(procFilePath("sys/kernel/threads-max"))
        if err != nil {
-                return fmt.Errorf("unable to retrieve limit number of threads: %q", err)
+                return fmt.Errorf("unable to retrieve limit number of threads: %w", err)
        }
        ch <- prometheus.MustNewConstMetric(c.threadLimit, prometheus.GaugeValue, float64(maxThreads))
@@ -91,7 +92,7 @@ func (c *processCollector) Update(ch chan<- prometheus.Metric) error {
        pidM, err := readUintFromFile(procFilePath("sys/kernel/pid_max"))
        if err != nil {
-                return fmt.Errorf("unable to retrieve limit number of maximum pids alloved: %q", err)
+                return fmt.Errorf("unable to retrieve limit number of maximum pids alloved: %w", err)
        }
        ch <- prometheus.MustNewConstMetric(c.pidUsed, prometheus.GaugeValue, float64(pids))
        ch <- prometheus.MustNewConstMetric(c.pidMax, prometheus.GaugeValue, float64(pidM))
@@ -110,7 +111,7 @@ func (c *processCollector) getAllocatedThreads() (int, map[string]int32, int, er
        for _, pid := range p {
                stat, err := pid.Stat()
                // PIDs can vanish between getting the list and getting stats.
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "file not found when retrieving stats for pid", "pid", pid, "err", err)
                        continue
                }
diff --git a/collector/schedstat_linux.go b/collector/schedstat_linux.go
index d2f04f6..9f29a7e 100644
--- a/collector/schedstat_linux.go
+++ b/collector/schedstat_linux.go
@@ -11,9 +11,12 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !noshedstat
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -70,7 +73,7 @@ func init() {
 func (c *schedstatCollector) Update(ch chan<- prometheus.Metric) error {
        stats, err := c.fs.Schedstat()
        if err != nil {
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "schedstat file does not exist")
                        return ErrNoData
                }
diff --git a/collector/sockstat_linux.go b/collector/sockstat_linux.go
index c7596c9..8f5a99f 100644
--- a/collector/sockstat_linux.go
+++ b/collector/sockstat_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -55,7 +56,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
        stat4, err := fs.NetSockstat()
        switch {
        case err == nil:
-        case os.IsNotExist(err):
+        case errors.Is(err, os.ErrNotExist):
                level.Debug(c.logger).Log("msg", "IPv4 sockstat statistics not found, skipping")
        default:
                return fmt.Errorf("failed to get IPv4 sockstat data: %w", err)
@@ -64,7 +65,7 @@ func (c *sockStatCollector) Update(ch chan<- prometheus.Metric) error {
        stat6, err := fs.NetSockstat6()
        switch {
        case err == nil:
-        case os.IsNotExist(err):
+        case errors.Is(err, os.ErrNotExist):
                level.Debug(c.logger).Log("msg", "IPv6 sockstat statistics not found, skipping")
        default:
                return fmt.Errorf("failed to get IPv6 sockstat data: %w", err)
diff --git a/collector/softnet_linux.go b/collector/softnet_linux.go
index e48f182..befec8e 100644
--- a/collector/softnet_linux.go
+++ b/collector/softnet_linux.go
@@ -72,7 +72,7 @@ func NewSoftnetCollector(logger log.Logger) (Collector, error) {
 func (c *softnetCollector) Update(ch chan<- prometheus.Metric) error {
        stats, err := c.fs.NetSoftnetStat()
        if err != nil {
-                return fmt.Errorf("could not get softnet statistics: %s", err)
+                return fmt.Errorf("could not get softnet statistics: %w", err)
        }
        for cpuNumber, cpuStats := range stats {
diff --git a/collector/supervisord.go b/collector/supervisord.go
index 33f3b8a..6a6b909 100644
--- a/collector/supervisord.go
+++ b/collector/supervisord.go
@@ -134,7 +134,7 @@ func (c *supervisordCollector) Update(ch chan<- prometheus.Metric) error {
        res, err := xrpc.Call("supervisor.getAllProcessInfo")
        if err != nil {
-                return fmt.Errorf("unable to call supervisord: %s", err)
+                return fmt.Errorf("unable to call supervisord: %w", err)
        }
        for _, p := range res.(xmlrpc.Array) {
diff --git a/collector/sysctl_bsd.go b/collector/sysctl_bsd.go
index 3038f41..a671bc2 100644
--- a/collector/sysctl_bsd.go
+++ b/collector/sysctl_bsd.go
@@ -12,7 +12,7 @@
 // limitations under the License.
 // +build freebsd dragonfly openbsd netbsd darwin
-// +build !nomeminfo
+// +build cgo
 package collector
diff --git a/collector/systemd_linux.go b/collector/systemd_linux.go
index 0827069..b374b37 100644
--- a/collector/systemd_linux.go
+++ b/collector/systemd_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "math"
        "regexp"
@@ -39,8 +40,10 @@ const (
 )
 var (
-        unitWhitelist          = kingpin.Flag("collector.systemd.unit-whitelist", "Regexp of systemd units to whitelist. Units must both match whitelist and not match blacklist to be included.").Default(".+").String()
+        unitInclude            = kingpin.Flag("collector.systemd.unit-include", "Regexp of systemd units to include. Units must both match include and not match exclude to be included.").Default(".+").String()
-        unitBlacklist          = kingpin.Flag("collector.systemd.unit-blacklist", "Regexp of systemd units to blacklist. Units must both match whitelist and not match blacklist to be included.").Default(".+\\.(automount|device|mount|scope|slice)").String()
+        oldUnitInclude         = kingpin.Flag("collector.systemd.unit-whitelist", "DEPRECATED: Use --collector.systemd.unit-include").Hidden().String()
+        unitExclude            = kingpin.Flag("collector.systemd.unit-exclude", "Regexp of systemd units to exclude. Units must both match include and not match exclude to be included.").Default(".+\\.(automount|device|mount|scope|slice)").String()
+        oldUnitExclude         = kingpin.Flag("collector.systemd.unit-blacklist", "DEPRECATED: Use collector.systemd.unit-exclude").Hidden().String()
        systemdPrivate         = kingpin.Flag("collector.systemd.private", "Establish a private, direct connection to systemd without dbus (Strongly discouraged since it requires root. For testing purposes only).").Hidden().Bool()
        enableTaskMetrics      = kingpin.Flag("collector.systemd.enable-task-metrics", "Enables service unit tasks metrics unit_tasks_current and unit_tasks_max").Bool()
        enableRestartsMetrics  = kingpin.Flag("collector.systemd.enable-restarts-metrics", "Enables service unit metric service_restart_total").Bool()
@@ -61,8 +64,8 @@ type systemdCollector struct {
        socketRefusedConnectionsDesc  *prometheus.Desc
        systemdVersionDesc            *prometheus.Desc
        systemdVersion                int
-        unitWhitelistPattern          *regexp.Regexp
+        unitIncludePattern            *regexp.Regexp
-        unitBlacklistPattern          *regexp.Regexp
+        unitExcludePattern            *regexp.Regexp
        logger                        log.Logger
 }
@@ -118,8 +121,27 @@ func NewSystemdCollector(logger log.Logger) (Collector, error) {
        systemdVersionDesc := prometheus.NewDesc(
                prometheus.BuildFQName(namespace, subsystem, "version"),
                "Detected systemd version", []string{}, nil)
-        unitWhitelistPattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitWhitelist))
-        unitBlacklistPattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitBlacklist))
+        if *oldUnitExclude != "" {
+                if *unitExclude == "" {
+                        level.Warn(logger).Log("msg", "--collector.systemd.unit-blacklist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-exclude")
+                        *unitExclude = *oldUnitExclude
+                } else {
+                        return nil, errors.New("--collector.systemd.unit-blacklist and --collector.systemd.unit-exclude are mutually exclusive")
+                }
+        }
+        if *oldUnitInclude != "" {
+                if *unitInclude == "" {
+                        level.Warn(logger).Log("msg", "--collector.systemd.unit-whitelist is DEPRECATED and will be removed in 2.0.0, use --collector.systemd.unit-include")
+                        *unitInclude = *oldUnitInclude
+                } else {
+                        return nil, errors.New("--collector.systemd.unit-whitelist and --collector.systemd.unit-include are mutually exclusive")
+                }
+        }
+        level.Info(logger).Log("msg", "Parsed flag --collector.systemd.unit-include", "flag", *unitInclude)
+        unitIncludePattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitInclude))
+        level.Info(logger).Log("msg", "Parsed flag --collector.systemd.unit-exclude", "flag", *unitExclude)
+        unitExcludePattern := regexp.MustCompile(fmt.Sprintf("^(?:%s)$", *unitExclude))
        systemdVersion := getSystemdVersion(logger)
        if systemdVersion < minSystemdVersionSystemState {
@@ -141,8 +163,8 @@ func NewSystemdCollector(logger log.Logger) (Collector, error) {
                socketRefusedConnectionsDesc:  socketRefusedConnectionsDesc,
                systemdVersionDesc:            systemdVersionDesc,
                systemdVersion:                systemdVersion,
-                unitWhitelistPattern:          unitWhitelistPattern,
+                unitIncludePattern:            unitIncludePattern,
-                unitBlacklistPattern:          unitBlacklistPattern,
+                unitExcludePattern:            unitExcludePattern,
                logger:                        logger,
        }, nil
 }
@@ -153,13 +175,13 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
        begin := time.Now()
        conn, err := newSystemdDbusConn()
        if err != nil {
-                return fmt.Errorf("couldn't get dbus connection: %s", err)
+                return fmt.Errorf("couldn't get dbus connection: %w", err)
        }
        defer conn.Close()
        allUnits, err := c.getAllUnits(conn)
        if err != nil {
-                return fmt.Errorf("couldn't get units: %s", err)
+                return fmt.Errorf("couldn't get units: %w", err)
        }
        level.Debug(c.logger).Log("msg", "getAllUnits took", "duration_seconds", time.Since(begin).Seconds())
@@ -169,7 +191,7 @@ func (c *systemdCollector) Update(ch chan<- prometheus.Metric) error {
        level.Debug(c.logger).Log("msg", "collectSummaryMetrics took", "duration_seconds", time.Since(begin).Seconds())
        begin = time.Now()
-        units := filterUnits(allUnits, c.unitWhitelistPattern, c.unitBlacklistPattern, c.logger)
+        units := filterUnits(allUnits, c.unitIncludePattern, c.unitExcludePattern, c.logger)
        level.Debug(c.logger).Log("msg", "filterUnits took", "duration_seconds", time.Since(begin).Seconds())
        var wg sync.WaitGroup
@@ -391,7 +413,7 @@ func (c *systemdCollector) collectSummaryMetrics(ch chan<- prometheus.Metric, su
 func (c *systemdCollector) collectSystemState(conn *dbus.Conn, ch chan<- prometheus.Metric) error {
        systemState, err := conn.GetManagerProperty("SystemState")
        if err != nil {
-                return fmt.Errorf("couldn't get system state: %s", err)
+                return fmt.Errorf("couldn't get system state: %w", err)
        }
        isSystemRunning := 0.0
        if systemState == `"running"` {
@@ -443,10 +465,10 @@ func summarizeUnits(units []unit) map[string]float64 {
        return summarized
 }
-func filterUnits(units []unit, whitelistPattern, blacklistPattern *regexp.Regexp, logger log.Logger) []unit {
+func filterUnits(units []unit, includePattern, excludePattern *regexp.Regexp, logger log.Logger) []unit {
        filtered := make([]unit, 0, len(units))
        for _, unit := range units {
-                if whitelistPattern.MatchString(unit.Name) && !blacklistPattern.MatchString(unit.Name) && unit.LoadState == "loaded" {
+                if includePattern.MatchString(unit.Name) && !excludePattern.MatchString(unit.Name) && unit.LoadState == "loaded" {
                        level.Debug(logger).Log("msg", "Adding unit", "unit", unit.Name)
                        filtered = append(filtered, unit)
                } else {
diff --git a/collector/systemd_linux_test.go b/collector/systemd_linux_test.go
index 613a1ab..93137f2 100644
--- a/collector/systemd_linux_test.go
+++ b/collector/systemd_linux_test.go
@@ -89,11 +89,11 @@ func getUnitListFixtures() [][]unit {
 func TestSystemdIgnoreFilter(t *testing.T) {
        fixtures := getUnitListFixtures()
-        whitelistPattern := regexp.MustCompile("^foo$")
+        includePattern := regexp.MustCompile("^foo$")
-        blacklistPattern := regexp.MustCompile("^bar$")
+        excludePattern := regexp.MustCompile("^bar$")
-        filtered := filterUnits(fixtures[0], whitelistPattern, blacklistPattern, log.NewNopLogger())
+        filtered := filterUnits(fixtures[0], includePattern, excludePattern, log.NewNopLogger())
        for _, unit := range filtered {
-                if blacklistPattern.MatchString(unit.Name) || !whitelistPattern.MatchString(unit.Name) {
+                if excludePattern.MatchString(unit.Name) || !includePattern.MatchString(unit.Name) {
                        t.Error(unit.Name, "should not be in the filtered list")
                }
        }
@@ -106,7 +106,7 @@ func TestSystemdIgnoreFilterDefaultKeepsAll(t *testing.T) {
        }
        fixtures := getUnitListFixtures()
        collector := c.(*systemdCollector)
-        filtered := filterUnits(fixtures[0], collector.unitWhitelistPattern, collector.unitBlacklistPattern, logger)
+        filtered := filterUnits(fixtures[0], collector.unitIncludePattern, collector.unitExcludePattern, logger)
        // Adjust fixtures by 3 "not-found" units.
        if len(filtered) != len(fixtures[0])-3 {
                t.Error("Default filters removed units")
diff --git a/collector/tcpstat_linux.go b/collector/tcpstat_linux.go
index db9c655..af5ae98 100644
--- a/collector/tcpstat_linux.go
+++ b/collector/tcpstat_linux.go
@@ -82,7 +82,7 @@ func NewTCPStatCollector(logger log.Logger) (Collector, error) {
 func (c *tcpStatCollector) Update(ch chan<- prometheus.Metric) error {
        tcpStats, err := getTCPStats(procFilePath("net/tcp"))
        if err != nil {
-                return fmt.Errorf("couldn't get tcpstats: %s", err)
+                return fmt.Errorf("couldn't get tcpstats: %w", err)
        }
        // if enabled ipv6 system
@@ -90,7 +90,7 @@ func (c *tcpStatCollector) Update(ch chan<- prometheus.Metric) error {
        if _, hasIPv6 := os.Stat(tcp6File); hasIPv6 == nil {
                tcp6Stats, err := getTCPStats(tcp6File)
                if err != nil {
-                        return fmt.Errorf("couldn't get tcp6stats: %s", err)
+                        return fmt.Errorf("couldn't get tcp6stats: %w", err)
                }
                for st, value := range tcp6Stats {
diff --git a/collector/textfile.go b/collector/textfile.go
index 64165e6..50c1807 100644
--- a/collector/textfile.go
+++ b/collector/textfile.go
@@ -238,14 +238,14 @@ func (c *textFileCollector) processFile(name string, ch chan<- prometheus.Metric
        path := filepath.Join(c.path, name)
        f, err := os.Open(path)
        if err != nil {
-                return nil, fmt.Errorf("failed to open textfile data file %q: %v", path, err)
+                return nil, fmt.Errorf("failed to open textfile data file %q: %w", path, err)
        }
        defer f.Close()
        var parser expfmt.TextParser
        families, err := parser.TextToMetricFamilies(f)
        if err != nil {
-                return nil, fmt.Errorf("failed to parse textfile data from %q: %v", path, err)
+                return nil, fmt.Errorf("failed to parse textfile data from %q: %w", path, err)
        }
        if hasTimestamps(families) {
@@ -267,7 +267,7 @@ func (c *textFileCollector) processFile(name string, ch chan<- prometheus.Metric
        // a failure does not appear fresh.
        stat, err := f.Stat()
        if err != nil {
-                return nil, fmt.Errorf("failed to stat %q: %v", path, err)
+                return nil, fmt.Errorf("failed to stat %q: %w", path, err)
        }
        t := stat.ModTime()
diff --git a/collector/udp_queues_linux.go b/collector/udp_queues_linux.go
index 512c010..e1b347e 100644
--- a/collector/udp_queues_linux.go
+++ b/collector/udp_queues_linux.go
@@ -16,6 +16,7 @@
 package collector
 import (
+        "errors"
        "fmt"
        "os"
@@ -41,7 +42,7 @@ func init() {
 func NewUDPqueuesCollector(logger log.Logger) (Collector, error) {
        fs, err := procfs.NewFS(*procPath)
        if err != nil {
-                return nil, fmt.Errorf("failed to open procfs: %v", err)
+                return nil, fmt.Errorf("failed to open procfs: %w", err)
        }
        return &udpQueuesCollector{
                fs: fs,
@@ -61,10 +62,10 @@ func (c *udpQueuesCollector) Update(ch chan<- prometheus.Metric) error {
                ch <- prometheus.MustNewConstMetric(c.desc, prometheus.GaugeValue, float64(s4.TxQueueLength), "tx", "v4")
                ch <- prometheus.MustNewConstMetric(c.desc, prometheus.GaugeValue, float64(s4.RxQueueLength), "rx", "v4")
        } else {
-                if os.IsNotExist(errIPv4) {
+                if errors.Is(errIPv4, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "not collecting ipv4 based metrics")
                } else {
-                        return fmt.Errorf("couldn't get upd queued bytes: %s", errIPv4)
+                        return fmt.Errorf("couldn't get upd queued bytes: %w", errIPv4)
                }
        }
@@ -73,14 +74,14 @@ func (c *udpQueuesCollector) Update(ch chan<- prometheus.Metric) error {
                ch <- prometheus.MustNewConstMetric(c.desc, prometheus.GaugeValue, float64(s6.TxQueueLength), "tx", "v6")
                ch <- prometheus.MustNewConstMetric(c.desc, prometheus.GaugeValue, float64(s6.RxQueueLength), "rx", "v6")
        } else {
-                if os.IsNotExist(errIPv6) {
+                if errors.Is(errIPv6, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "not collecting ipv6 based metrics")
                } else {
-                        return fmt.Errorf("couldn't get upd6 queued bytes: %s", errIPv6)
+                        return fmt.Errorf("couldn't get upd6 queued bytes: %w", errIPv6)
                }
        }
-        if os.IsNotExist(errIPv4) && os.IsNotExist(errIPv6) {
+        if errors.Is(errIPv4, os.ErrNotExist) && errors.Is(errIPv6, os.ErrNotExist) {
                return ErrNoData
        }
        return nil
diff --git a/collector/wifi_linux.go b/collector/wifi_linux.go
index 118e714..076982d 100644
--- a/collector/wifi_linux.go
+++ b/collector/wifi_linux.go
@@ -11,10 +11,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nowifi
 package collector
 import (
        "encoding/json"
+        "errors"
        "fmt"
        "io/ioutil"
        "os"
@@ -165,11 +168,11 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
        stat, err := newWifiStater(*collectorWifi)
        if err != nil {
                // Cannot access wifi metrics, report no error.
-                if os.IsNotExist(err) {
+                if errors.Is(err, os.ErrNotExist) {
                        level.Debug(c.logger).Log("msg", "wifi collector metrics are not available for this system")
                        return ErrNoData
                }
-                if os.IsPermission(err) {
+                if errors.Is(err, os.ErrPermission) {
                        level.Debug(c.logger).Log("msg", "wifi collector got permission denied when accessing metrics")
                        return ErrNoData
                }
@@ -199,14 +202,14 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
                )
                // When a statistic is not available for a given interface, package wifi
-                // returns an error compatible with os.IsNotExist.  We leverage this to
+                // returns a os.ErrNotExist error.  We leverage this to only export
-                // only export metrics which are actually valid for given interface types.
+                // metrics which are actually valid for given interface types.
                bss, err := stat.BSS(ifi)
                switch {
                case err == nil:
                        c.updateBSSStats(ch, ifi.Name, bss)
-                case os.IsNotExist(err):
+                case errors.Is(err, os.ErrNotExist):
                        level.Debug(c.logger).Log("msg", "BSS information not found for wifi device", "name", ifi.Name)
                default:
                        return fmt.Errorf("failed to retrieve BSS for device %s: %v",
@@ -219,7 +222,7 @@ func (c *wifiCollector) Update(ch chan<- prometheus.Metric) error {
                        for _, station := range stations {
                                c.updateStationStats(ch, ifi.Name, station)
                        }
-                case os.IsNotExist(err):
+                case errors.Is(err, os.ErrNotExist):
                        level.Debug(c.logger).Log("msg", "station information not found for wifi device", "name", ifi.Name)
                default:
                        return fmt.Errorf("failed to retrieve station info for device %q: %v",
diff --git a/collector/xfs_linux.go b/collector/xfs_linux.go
index 77824c5..36dfff5 100644
--- a/collector/xfs_linux.go
+++ b/collector/xfs_linux.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !noxfs
 package collector
 import (
diff --git a/collector/zfs_freebsd.go b/collector/zfs_freebsd.go
index a625bbc..2f20096 100644
--- a/collector/zfs_freebsd.go
+++ b/collector/zfs_freebsd.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nozfs
 package collector
 import (
@@ -248,7 +250,7 @@ func (c *zfsCollector) Update(ch chan<- prometheus.Metric) error {
        for _, m := range c.sysctls {
                v, err := m.Value()
                if err != nil {
-                        return fmt.Errorf("couldn't get sysctl: %s", err)
+                        return fmt.Errorf("couldn't get sysctl: %w", err)
                }
                ch <- prometheus.MustNewConstMetric(
diff --git a/collector/zfs_linux.go b/collector/zfs_linux.go
index e2c9749..f55d98a 100644
--- a/collector/zfs_linux.go
+++ b/collector/zfs_linux.go
@@ -11,6 +11,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build !nozfs
 package collector
 import (
@@ -185,7 +187,7 @@ func (c *zfsCollector) parsePoolProcfsFile(reader io.Reader, zpoolPath string, h
                        value, err := strconv.ParseUint(line[i], 10, 64)
                        if err != nil {
-                                return fmt.Errorf("could not parse expected integer value for %q: %v", key, err)
+                                return fmt.Errorf("could not parse expected integer value for %q: %w", key, err)
                        }
                        handler(zpoolName, zfsSysctl(key), value)
                }
diff --git a/collector/zfs_solaris.go b/collector/zfs_solaris.go
index bfda64f..1c0460c 100644
--- a/collector/zfs_solaris.go
+++ b/collector/zfs_solaris.go
@@ -12,6 +12,7 @@
 // limitations under the License.
 // +build solaris
+// +build !nozfs
 package collector
diff --git a/go.mod b/go.mod
index 8c1fa87..a98b7db 100644
--- a/go.mod
+++ b/go.mod
@@ -20,7 +20,7 @@ require (
        github.com/prometheus/client_golang v1.6.0
        github.com/prometheus/client_model v0.2.0
        github.com/prometheus/common v0.10.0
-        github.com/prometheus/procfs v0.0.11
+        github.com/prometheus/procfs v0.1.3
        github.com/siebenmann/go-kstat v0.0.0-20200303194639-4e8294f9e9d5
        github.com/soundcloud/go-runit v0.0.0-20150630195641-06ad41a06c4a
        go.uber.org/multierr v1.5.0 // indirect
diff --git a/go.sum b/go.sum
index f810565..6697ba5 100644
--- a/go.sum
+++ b/go.sum
@@ -289,6 +289,8 @@ github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsT
 github.com/prometheus/procfs v0.0.8/go.mod h1:7Qr8sr6344vo1JqZ6HhLceV9o3AJ1Ff+GxbHq6oeK9A=
 github.com/prometheus/procfs v0.0.11 h1:DhHlBtkHWPYi8O2y31JkK0TF+DGM+51OopZjH/Ia5qI=
 github.com/prometheus/procfs v0.0.11/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
+github.com/prometheus/procfs v0.1.3 h1:F0+tqvhOksq22sc6iCHF5WGlWjdwj92p0udFh1VFBS8=
+github.com/prometheus/procfs v0.1.3/go.mod h1:lV6e/gmhEcM9IjHGsFOCxxuZ+z1YqCvr4OA4YeYWdaU=
 github.com/rcrowley/go-metrics v0.0.0-20181016184325-3113b8401b8a/go.mod h1:bCqnVzQkZxMG4s8nGwiZ5l3QUCyqpo9Y+/ZMZ9VjZe4=
 github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
 github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
diff --git a/https/web-config.yml b/https/web-config.yml
index 9937291..7d40d9b 100644
--- a/https/web-config.yml
+++ b/https/web-config.yml
@@ -1,11 +1,6 @@
-tls_config:
+# Minimal TLS configuration example. Additionally, a certificate and a key file
-  # Certificate and key files for server to use to authenticate to client
+# are needed.
-  cert_file: <filename>
+tls_server_config:
-  key_file: <filename>
+  cert_file: server.crt
+  key_file: server.key
-  # Server policy for client authentication. Maps to ClientAuth Policies
-  # For more detail on clientAuth options: [ClientAuthType](https://golang.org/pkg/crypto/tls/#ClientAuthType)
-  [ client_auth_type: <string> | default = "NoClientCert" ]
-  # CA certificate for client certificate authentication to the server
-  [ client_ca_file: <filename> ]
diff --git a/vendor/github.com/prometheus/procfs/Makefile.common b/vendor/github.com/prometheus/procfs/Makefile.common
index b978dfc..9320176 100644
--- a/vendor/github.com/prometheus/procfs/Makefile.common
+++ b/vendor/github.com/prometheus/procfs/Makefile.common
@@ -150,6 +150,17 @@ else
        $(GO) get $(GOOPTS) -t ./...
 endif
+.PHONY: update-go-deps
+update-go-deps:
+        @echo ">> updating Go dependencies"
+        @for m in $$($(GO) list -mod=readonly -m -f '{{ if and (not .Indirect) (not .Main)}}{{.Path}}{{end}}' all); do \
+                $(GO) get $$m; \
+        done
+        GO111MODULE=$(GO111MODULE) $(GO) mod tidy
+ifneq (,$(wildcard vendor))
+        GO111MODULE=$(GO111MODULE) $(GO) mod vendor
+endif
 .PHONY: common-test-short
 common-test-short: $(GOTEST_DIR)
        @echo ">> running short tests"
diff --git a/vendor/github.com/prometheus/procfs/bcache/bcache.go b/vendor/github.com/prometheus/procfs/bcache/bcache.go
index df724ed..1176a55 100644
--- a/vendor/github.com/prometheus/procfs/bcache/bcache.go
+++ b/vendor/github.com/prometheus/procfs/bcache/bcache.go
@@ -43,10 +43,11 @@ type BcacheStats struct { // nolint:golint
 // BdevStats contains statistics for one backing device.
 type BdevStats struct {
-        Name      string
+        Name               string
-        DirtyData uint64
+        DirtyData          uint64
-        FiveMin   PeriodStats
+        FiveMin            PeriodStats
-        Total     PeriodStats
+        Total              PeriodStats
+        WritebackRateDebug WritebackRateDebugStats
 }
 // CacheStats contains statistics for one cache device.
@@ -82,3 +83,14 @@ type PeriodStats struct {
        CacheMisses         uint64
        CacheReadaheads     uint64
 }
+// WritebackRateDebugStats contains bcache writeback statistics.
+type WritebackRateDebugStats struct {
+        Rate         uint64
+        Dirty        uint64
+        Target       uint64
+        Proportional int64
+        Integral     int64
+        Change       int64
+        NextIO       int64
+}
diff --git a/vendor/github.com/prometheus/procfs/bcache/get.go b/vendor/github.com/prometheus/procfs/bcache/get.go
index 67fcf8b..c4747ea 100644
--- a/vendor/github.com/prometheus/procfs/bcache/get.go
+++ b/vendor/github.com/prometheus/procfs/bcache/get.go
@@ -174,6 +174,17 @@ func dehumanize(hbytes []byte) (uint64, error) {
        return res, nil
 }
+func dehumanizeSigned(str string) (int64, error) {
+        value, err := dehumanize([]byte(strings.TrimPrefix(str, "-")))
+        if err != nil {
+                return 0, err
+        }
+        if strings.HasPrefix(str, "-") {
+                return int64(-value), nil
+        }
+        return int64(value), nil
+}
 type parser struct {
        uuidPath   string
        subDir     string
@@ -232,6 +243,72 @@ func parsePriorityStats(line string, ps *PriorityStats) error {
        return nil
 }
+// ParseWritebackRateDebug parses lines from the writeback_rate_debug file.
+func parseWritebackRateDebug(line string, wrd *WritebackRateDebugStats) error {
+        switch {
+        case strings.HasPrefix(line, "rate:"):
+                fields := strings.Fields(line)
+                rawValue := fields[len(fields)-1]
+                valueStr := strings.TrimSuffix(rawValue, "/sec")
+                value, err := dehumanize([]byte(valueStr))
+                if err != nil {
+                        return err
+                }
+                wrd.Rate = value
+        case strings.HasPrefix(line, "dirty:"):
+                fields := strings.Fields(line)
+                valueStr := fields[len(fields)-1]
+                value, err := dehumanize([]byte(valueStr))
+                if err != nil {
+                        return err
+                }
+                wrd.Dirty = value
+        case strings.HasPrefix(line, "target:"):
+                fields := strings.Fields(line)
+                valueStr := fields[len(fields)-1]
+                value, err := dehumanize([]byte(valueStr))
+                if err != nil {
+                        return err
+                }
+                wrd.Target = value
+        case strings.HasPrefix(line, "proportional:"):
+                fields := strings.Fields(line)
+                valueStr := fields[len(fields)-1]
+                value, err := dehumanizeSigned(valueStr)
+                if err != nil {
+                        return err
+                }
+                wrd.Proportional = value
+        case strings.HasPrefix(line, "integral:"):
+                fields := strings.Fields(line)
+                valueStr := fields[len(fields)-1]
+                value, err := dehumanizeSigned(valueStr)
+                if err != nil {
+                        return err
+                }
+                wrd.Integral = value
+        case strings.HasPrefix(line, "change:"):
+                fields := strings.Fields(line)
+                rawValue := fields[len(fields)-1]
+                valueStr := strings.TrimSuffix(rawValue, "/sec")
+                value, err := dehumanizeSigned(valueStr)
+                if err != nil {
+                        return err
+                }
+                wrd.Change = value
+        case strings.HasPrefix(line, "next io:"):
+                fields := strings.Fields(line)
+                rawValue := fields[len(fields)-1]
+                valueStr := strings.TrimSuffix(rawValue, "ms")
+                value, err := strconv.ParseInt(valueStr, 10, 64)
+                if err != nil {
+                        return err
+                }
+                wrd.NextIO = value
+        }
+        return nil
+}
 func (p *parser) getPriorityStats() PriorityStats {
        var res PriorityStats
@@ -263,6 +340,35 @@ func (p *parser) getPriorityStats() PriorityStats {
        return res
 }
+func (p *parser) getWritebackRateDebug() WritebackRateDebugStats {
+        var res WritebackRateDebugStats
+        if p.err != nil {
+                return res
+        }
+        path := path.Join(p.currentDir, "writeback_rate_debug")
+        file, err := os.Open(path)
+        if err != nil {
+                p.err = fmt.Errorf("failed to read: %s", path)
+                return res
+        }
+        defer file.Close()
+        scanner := bufio.NewScanner(file)
+        for scanner.Scan() {
+                err = parseWritebackRateDebug(scanner.Text(), &res)
+                if err != nil {
+                        p.err = fmt.Errorf("failed to parse: %s (%s)", path, err)
+                        return res
+                }
+        }
+        if err := scanner.Err(); err != nil {
+                p.err = fmt.Errorf("failed to parse: %s (%s)", path, err)
+                return res
+        }
+        return res
+}
 // GetStats collects from sysfs files data tied to one bcache ID.
 func GetStats(uuidPath string, priorityStats bool) (*Stats, error) {
        var bs Stats
@@ -339,6 +445,9 @@ func GetStats(uuidPath string, priorityStats bool) (*Stats, error) {
                par.setSubDir(bds.Name)
                bds.DirtyData = par.readValue("dirty_data")
+                wrd := par.getWritebackRateDebug()
+                bds.WritebackRateDebug = wrd
                // dir <uuidPath>/<bds.Name>/stats_five_minute
                par.setSubDir(bds.Name, "stats_five_minute")
                bds.FiveMin.Bypassed = par.readValue("bypassed")
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo.go b/vendor/github.com/prometheus/procfs/cpuinfo.go
index 2e02215..31d42f7 100644
--- a/vendor/github.com/prometheus/procfs/cpuinfo.go
+++ b/vendor/github.com/prometheus/procfs/cpuinfo.go
@@ -11,11 +11,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
+// +build linux
 package procfs
 import (
        "bufio"
        "bytes"
+        "errors"
+        "regexp"
        "strconv"
        "strings"
@@ -52,6 +56,11 @@ type CPUInfo struct {
        PowerManagement string
 }
+var (
+        cpuinfoClockRegexp          = regexp.MustCompile(`([\d.]+)`)
+        cpuinfoS390XProcessorRegexp = regexp.MustCompile(`^processor\s+(\d+):.*`)
+)
 // CPUInfo returns information about current system CPUs.
 // See https://www.kernel.org/doc/Documentation/filesystems/proc.txt
 func (fs FS) CPUInfo() ([]CPUInfo, error) {
@@ -62,14 +71,26 @@ func (fs FS) CPUInfo() ([]CPUInfo, error) {
        return parseCPUInfo(data)
 }
-// parseCPUInfo parses data from /proc/cpuinfo
+func parseCPUInfoX86(info []byte) ([]CPUInfo, error) {
-func parseCPUInfo(info []byte) ([]CPUInfo, error) {
-        cpuinfo := []CPUInfo{}
-        i := -1
        scanner := bufio.NewScanner(bytes.NewReader(info))
+        // find the first "processor" line
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        v, err := strconv.ParseUint(field[1], 0, 32)
+        if err != nil {
+                return nil, err
+        }
+        firstcpu := CPUInfo{Processor: uint(v)}
+        cpuinfo := []CPUInfo{firstcpu}
+        i := 0
        for scanner.Scan() {
                line := scanner.Text()
-                if strings.TrimSpace(line) == "" {
+                if !strings.Contains(line, ":") {
                        continue
                }
                field := strings.SplitN(line, ": ", 2)
@@ -82,7 +103,7 @@ func parseCPUInfo(info []byte) ([]CPUInfo, error) {
                                return nil, err
                        }
                        cpuinfo[i].Processor = uint(v)
-                case "vendor_id":
+                case "vendor", "vendor_id":
                        cpuinfo[i].VendorID = field[1]
                case "cpu family":
                        cpuinfo[i].CPUFamily = field[1]
@@ -163,5 +184,237 @@ func parseCPUInfo(info []byte) ([]CPUInfo, error) {
                }
        }
        return cpuinfo, nil
+}
+func parseCPUInfoARM(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+        firstLine := firstNonEmptyLine(scanner)
+        match, _ := regexp.MatchString("^[Pp]rocessor", firstLine)
+        if !match || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        featuresLine := ""
+        commonCPUInfo := CPUInfo{}
+        i := 0
+        if strings.TrimSpace(field[0]) == "Processor" {
+                commonCPUInfo = CPUInfo{ModelName: field[1]}
+                i = -1
+        } else {
+                v, err := strconv.ParseUint(field[1], 0, 32)
+                if err != nil {
+                        return nil, err
+                }
+                firstcpu := CPUInfo{Processor: uint(v)}
+                cpuinfo = []CPUInfo{firstcpu}
+        }
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        cpuinfo = append(cpuinfo, commonCPUInfo) // start of the next processor
+                        i++
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].Processor = uint(v)
+                case "BogoMIPS":
+                        if i == -1 {
+                                cpuinfo = append(cpuinfo, commonCPUInfo) // There is only one processor
+                                i++
+                                cpuinfo[i].Processor = 0
+                        }
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].BogoMips = v
+                case "Features":
+                        featuresLine = line
+                case "model name":
+                        cpuinfo[i].ModelName = field[1]
+                }
+        }
+        fields := strings.SplitN(featuresLine, ": ", 2)
+        for i := range cpuinfo {
+                cpuinfo[i].Flags = strings.Fields(fields[1])
+        }
+        return cpuinfo, nil
+}
+func parseCPUInfoS390X(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "vendor_id") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        commonCPUInfo := CPUInfo{VendorID: field[1]}
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "bogomips per cpu":
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        commonCPUInfo.BogoMips = v
+                case "features":
+                        commonCPUInfo.Flags = strings.Fields(field[1])
+                }
+                if strings.HasPrefix(line, "processor") {
+                        match := cpuinfoS390XProcessorRegexp.FindStringSubmatch(line)
+                        if len(match) < 2 {
+                                return nil, errors.New("Invalid line found in cpuinfo: " + line)
+                        }
+                        cpu := commonCPUInfo
+                        v, err := strconv.ParseUint(match[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpu.Processor = uint(v)
+                        cpuinfo = append(cpuinfo, cpu)
+                }
+                if strings.HasPrefix(line, "cpu number") {
+                        break
+                }
+        }
+        i := 0
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "cpu number":
+                        i++
+                case "cpu MHz dynamic":
+                        clock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))
+                        v, err := strconv.ParseFloat(clock, 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].CPUMHz = v
+                }
+        }
+        return cpuinfo, nil
+}
+func parseCPUInfoMips(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+        // find the first "processor" line
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "system type") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        cpuinfo := []CPUInfo{}
+        systemType := field[1]
+        i := 0
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        i = int(v)
+                        cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor
+                        cpuinfo[i].Processor = uint(v)
+                        cpuinfo[i].VendorID = systemType
+                case "cpu model":
+                        cpuinfo[i].ModelName = field[1]
+                case "BogoMIPS":
+                        v, err := strconv.ParseFloat(field[1], 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].BogoMips = v
+                }
+        }
+        return cpuinfo, nil
+}
+func parseCPUInfoPPC(info []byte) ([]CPUInfo, error) {
+        scanner := bufio.NewScanner(bytes.NewReader(info))
+        firstLine := firstNonEmptyLine(scanner)
+        if !strings.HasPrefix(firstLine, "processor") || !strings.Contains(firstLine, ":") {
+                return nil, errors.New("invalid cpuinfo file: " + firstLine)
+        }
+        field := strings.SplitN(firstLine, ": ", 2)
+        v, err := strconv.ParseUint(field[1], 0, 32)
+        if err != nil {
+                return nil, err
+        }
+        firstcpu := CPUInfo{Processor: uint(v)}
+        cpuinfo := []CPUInfo{firstcpu}
+        i := 0
+        for scanner.Scan() {
+                line := scanner.Text()
+                if !strings.Contains(line, ":") {
+                        continue
+                }
+                field := strings.SplitN(line, ": ", 2)
+                switch strings.TrimSpace(field[0]) {
+                case "processor":
+                        cpuinfo = append(cpuinfo, CPUInfo{}) // start of the next processor
+                        i++
+                        v, err := strconv.ParseUint(field[1], 0, 32)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].Processor = uint(v)
+                case "cpu":
+                        cpuinfo[i].VendorID = field[1]
+                case "clock":
+                        clock := cpuinfoClockRegexp.FindString(strings.TrimSpace(field[1]))
+                        v, err := strconv.ParseFloat(clock, 64)
+                        if err != nil {
+                                return nil, err
+                        }
+                        cpuinfo[i].CPUMHz = v
+                }
+        }
+        return cpuinfo, nil
+}
+// firstNonEmptyLine advances the scanner to the first non-empty line
+// and returns the contents of that line
+func firstNonEmptyLine(scanner *bufio.Scanner) string {
+        for scanner.Scan() {
+                line := scanner.Text()
+                if strings.TrimSpace(line) != "" {
+                        return line
+                }
+        }
+        return ""
 }
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_arm.go b/vendor/github.com/prometheus/procfs/cpuinfo_arm.go
new file mode 100644
index 0000000..8355507
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_arm.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoARM
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_arm64.go b/vendor/github.com/prometheus/procfs/cpuinfo_arm64.go
new file mode 100644
index 0000000..4f5d172
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_arm64.go
@@ -0,0 +1,19 @@
+// Copyright 2020 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.
+// +build linux
+// +build arm64
+package procfs
+var parseCPUInfo = parseCPUInfoARM
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_default.go b/vendor/github.com/prometheus/procfs/cpuinfo_default.go
new file mode 100644
index 0000000..d5bedf9
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_default.go
@@ -0,0 +1,19 @@
+// Copyright 2020 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.
+// +build linux
+// +build 386 amd64
+package procfs
+var parseCPUInfo = parseCPUInfoX86
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_mips.go b/vendor/github.com/prometheus/procfs/cpuinfo_mips.go
new file mode 100644
index 0000000..22d93f8
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_mips.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoMips
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_mips64.go b/vendor/github.com/prometheus/procfs/cpuinfo_mips64.go
new file mode 100644
index 0000000..22d93f8
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_mips64.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoMips
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_mips64le.go b/vendor/github.com/prometheus/procfs/cpuinfo_mips64le.go
new file mode 100644
index 0000000..22d93f8
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_mips64le.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoMips
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_mipsle.go b/vendor/github.com/prometheus/procfs/cpuinfo_mipsle.go
new file mode 100644
index 0000000..22d93f8
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_mipsle.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoMips
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_ppc64.go b/vendor/github.com/prometheus/procfs/cpuinfo_ppc64.go
new file mode 100644
index 0000000..64aee9c
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_ppc64.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoPPC
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_ppc64le.go b/vendor/github.com/prometheus/procfs/cpuinfo_ppc64le.go
new file mode 100644
index 0000000..64aee9c
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_ppc64le.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoPPC
diff --git a/vendor/github.com/prometheus/procfs/cpuinfo_s390x.go b/vendor/github.com/prometheus/procfs/cpuinfo_s390x.go
new file mode 100644
index 0000000..26814ee
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/cpuinfo_s390x.go
@@ -0,0 +1,18 @@
+// Copyright 2020 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.
+// +build linux
+package procfs
+var parseCPUInfo = parseCPUInfoS390X
diff --git a/vendor/github.com/prometheus/procfs/fixtures.ttar b/vendor/github.com/prometheus/procfs/fixtures.ttar
index 45a7321..868c857 100644
--- a/vendor/github.com/prometheus/procfs/fixtures.ttar
+++ b/vendor/github.com/prometheus/procfs/fixtures.ttar
@@ -173,6 +173,283 @@ Lines: 1
 411605849 93680043 79
 Mode: 644
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/26231/smaps
+Lines: 252
+00400000-00cb1000 r-xp 00000000 fd:01 952273                             /bin/alertmanager
+Size:               8900 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                2952 kB
+Pss:                2952 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:      2952 kB
+Private_Dirty:         0 kB
+Referenced:         2864 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd ex mr mw me dw sd 
+00cb1000-016b0000 r--p 008b1000 fd:01 952273                             /bin/alertmanager
+Size:              10236 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                6152 kB
+Pss:                6152 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:      6152 kB
+Private_Dirty:         0 kB
+Referenced:         5308 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd mr mw me dw sd 
+016b0000-0171a000 rw-p 012b0000 fd:01 952273                             /bin/alertmanager
+Size:                424 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                 176 kB
+Pss:                 176 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:        84 kB
+Private_Dirty:        92 kB
+Referenced:          176 kB
+Anonymous:            92 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                 12 kB
+SwapPss:              12 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me dw ac sd 
+0171a000-0173f000 rw-p 00000000 00:00 0 
+Size:                148 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                  76 kB
+Pss:                  76 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:        76 kB
+Referenced:           76 kB
+Anonymous:            76 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me ac sd 
+c000000000-c000400000 rw-p 00000000 00:00 0 
+Size:               4096 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                2564 kB
+Pss:                2564 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:        20 kB
+Private_Dirty:      2544 kB
+Referenced:         2544 kB
+Anonymous:          2564 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:               1100 kB
+SwapPss:            1100 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me ac sd 
+c000400000-c001600000 rw-p 00000000 00:00 0 
+Size:              18432 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:               16024 kB
+Pss:               16024 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:      5864 kB
+Private_Dirty:     10160 kB
+Referenced:        11944 kB
+Anonymous:         16024 kB
+LazyFree:           5848 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                440 kB
+SwapPss:             440 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me ac sd nh 
+c001600000-c004000000 rw-p 00000000 00:00 0 
+Size:              43008 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   0 kB
+Pss:                   0 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         0 kB
+Referenced:            0 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me ac sd 
+7f0ab95ca000-7f0abbb7b000 rw-p 00000000 00:00 0 
+Size:              38596 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                1992 kB
+Pss:                1992 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:       476 kB
+Private_Dirty:      1516 kB
+Referenced:         1828 kB
+Anonymous:          1992 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                384 kB
+SwapPss:             384 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me ac sd 
+7ffc07ecf000-7ffc07ef0000 rw-p 00000000 00:00 0                          [stack]
+Size:                132 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   8 kB
+Pss:                   8 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         8 kB
+Referenced:            8 kB
+Anonymous:             8 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  4 kB
+SwapPss:               4 kB
+Locked:                0 kB
+VmFlags: rd wr mr mw me gd ac 
+7ffc07f9e000-7ffc07fa1000 r--p 00000000 00:00 0                          [vvar]
+Size:                 12 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   0 kB
+Pss:                   0 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         0 kB
+Referenced:            0 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd mr pf io de dd sd 
+7ffc07fa1000-7ffc07fa3000 r-xp 00000000 00:00 0                          [vdso]
+Size:                  8 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   4 kB
+Pss:                   0 kB
+Shared_Clean:          4 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         0 kB
+Referenced:            4 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd ex mr mw me de sd 
+ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0                  [vsyscall]
+Size:                  4 kB
+KernelPageSize:        4 kB
+MMUPageSize:           4 kB
+Rss:                   0 kB
+Pss:                   0 kB
+Shared_Clean:          0 kB
+Shared_Dirty:          0 kB
+Private_Clean:         0 kB
+Private_Dirty:         0 kB
+Referenced:            0 kB
+Anonymous:             0 kB
+LazyFree:              0 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:                  0 kB
+SwapPss:               0 kB
+Locked:                0 kB
+VmFlags: rd ex 
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/26231/smaps_rollup
+Lines: 17
+00400000-ffffffffff601000 ---p 00000000 00:00 0                          [rollup]
+Rss:               29948 kB
+Pss:               29944 kB
+Shared_Clean:          4 kB
+Shared_Dirty:          0 kB
+Private_Clean:     15548 kB
+Private_Dirty:     14396 kB
+Referenced:        24752 kB
+Anonymous:         20756 kB
+LazyFree:           5848 kB
+AnonHugePages:         0 kB
+ShmemPmdMapped:        0 kB
+Shared_Hugetlb:        0 kB
+Private_Hugetlb:       0 kB
+Swap:               1940 kB
+SwapPss:            1940 kB
+Locked:                0 kB
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/proc/26231/stat
 Lines: 1
 26231 (vim) R 5392 7446 5392 34835 7446 4218880 32533 309516 26 82 1677 44 158 99 20 0 1 0 82375 56274944 1981 18446744073709551615 4194304 6294284 140736914091744 140736914087944 139965136429984 0 0 12288 1870679807 0 0 0 17 0 0 0 31 0 0 8391624 8481048 16420864 140736914093252 140736914093279 140736914093279 140736914096107 0
@@ -235,6 +512,11 @@ voluntary_ctxt_switches:	4742839
 nonvoluntary_ctxt_switches:     1727500
 Mode: 644
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/26231/wchan
+Lines: 1
+poll_schedule_timeoutEOF
+Mode: 664
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/proc/26232
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -310,6 +592,11 @@ Lines: 1
 33 (ata_sff) S 2 0 0 0 -1 69238880 0 0 0 0 0 0 0 0 0 -20 1 0 5 0 0 18446744073709551615 0 0 0 0 0 0 0 2147483647 0 18446744073709551615 0 0 17 1 0 0 0 0 0 0 0 0 0 0 0 0 0
 Mode: 644
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/26232/wchan
+Lines: 1
+0EOF
+Mode: 664
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/proc/26233
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -1554,7 +1841,7 @@ max keysize  : 32
 Mode: 444
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/proc/diskstats
-Lines: 49
+Lines: 52
   1       0 ram0 0 0 0 0 0 0 0 0 0 0 0
   1       1 ram1 0 0 0 0 0 0 0 0 0 0 0
   1       2 ram2 0 0 0 0 0 0 0 0 0 0 0
@@ -1604,11 +1891,45 @@ Lines: 49
   8       0 sdb 326552 841 9657779 84 41822 2895 1972905 5007 0 60730 67070 68851 0 1925173784 11130
   8       1 sdb1 231 3 34466 4 24 23 106 0 0 64 64 0 0 0 0
   8       2 sdb2 326310 838 9622281 67 40726 2872 1972799 4924 0 58250 64567 68851 0 1925173784 11130
+   8       0 sdc 14202 71 579164 21861 2995 1589 180500 40875 0 11628 55200 0 0 0 0 127 182
+   8       1 sdc1 1027 0 13795 5021 2 0 4096 3 0 690 4579 0 0 0 0 0 0
+   8       2 sdc2 13126 71 561749 16802 2830 1589 176404 40620 0 10931 50449 0 0 0 0 0 0
 Mode: 664
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/proc/fs
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/proc/fs/fscache
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/fs/fscache/stats
+Lines: 24
+FS-Cache statistics
+Cookies: idx=3 dat=67877 spc=0
+Objects: alc=67473 nal=0 avl=67473 ded=388
+ChkAux : non=12 ok=33 upd=44 obs=55
+Pages  : mrk=547164 unc=364577
+Acquire: n=67880 nul=98 noc=25 ok=67780 nbf=39 oom=26
+Lookups: n=67473 neg=67470 pos=58 crt=67473 tmo=85
+Invals : n=14 run=13
+Updates: n=7 nul=3 run=8
+Relinqs: n=394 nul=1 wcr=2 rtr=3
+AttrChg: n=6 ok=5 nbf=4 oom=3 run=2
+Allocs : n=20 ok=19 wt=18 nbf=17 int=16
+Allocs : ops=15 owt=14 abt=13
+Retrvls: n=151959 ok=82823 wt=23467 nod=69136 nbf=15 int=69 oom=43
+Retrvls: ops=151959 owt=42747 abt=44
+Stores : n=225565 ok=225565 agn=12 nbf=13 oom=14
+Stores : ops=69156 run=294721 pgs=225565 rxd=225565 olm=43
+VmScan : nos=364512 gon=2 bsy=43 can=12 wt=66
+Ops    : pend=42753 run=221129 enq=628798 can=11 rej=88
+Ops    : ini=377538 dfr=27 rel=377538 gc=37
+CacheOp: alo=1 luo=2 luc=3 gro=4
+CacheOp: inv=5 upo=6 dro=7 pto=8 atc=9 syn=10
+CacheOp: rap=11 ras=12 alp=13 als=14 wrp=15 ucp=16 dsp=17
+CacheEv: nsp=18 stl=19 rtr=20 cul=21EOF
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/proc/fs/xfs
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -2025,6 +2346,32 @@ Mode: 644
 Directory: fixtures/proc/sys
 Mode: 775
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/proc/sys/kernel
+Mode: 775
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/proc/sys/kernel/random
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/sys/kernel/random/entropy_avail
+Lines: 1
+3943
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/sys/kernel/random/poolsize
+Lines: 1
+4096
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/sys/kernel/random/urandom_min_reseed_secs
+Lines: 1
+60
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/proc/sys/kernel/random/write_wakeup_threshold
+Lines: 1
+3072
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/proc/sys/vm
 Mode: 775
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -2526,6 +2873,237 @@ Mode: 664
 Directory: fixtures/sys/block/sda
 Mode: 775
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/sys/block/sda/queue
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/add_random
+Lines: 1
+1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/chunk_sectors
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/dax
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/discard_granularity
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/discard_max_bytes
+Lines: 1
+0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/discard_max_hw_bytes
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/discard_zeroes_data
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/fua
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/hw_sector_size
+Lines: 1
+512
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/io_poll
+Lines: 1
+0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/io_poll_delay
+Lines: 1
+-1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/io_timeout
+Lines: 1
+30000
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/sys/block/sda/queue/iosched
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/back_seek_max
+Lines: 1
+16384
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/back_seek_penalty
+Lines: 1
+2
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/fifo_expire_async
+Lines: 1
+250
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/fifo_expire_sync
+Lines: 1
+125
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/low_latency
+Lines: 1
+1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/max_budget
+Lines: 1
+0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/slice_idle
+Lines: 1
+8
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/slice_idle_us
+Lines: 1
+8000
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/strict_guarantees
+Lines: 1
+0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iosched/timeout_sync
+Lines: 1
+125
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/iostats
+Lines: 1
+1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/logical_block_size
+Lines: 1
+512
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_discard_segments
+Lines: 1
+1
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_hw_sectors_kb
+Lines: 1
+32767
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_integrity_segments
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_sectors_kb
+Lines: 1
+1280
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_segment_size
+Lines: 1
+65536
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/max_segments
+Lines: 1
+168
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/minimum_io_size
+Lines: 1
+512
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/nomerges
+Lines: 1
+0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/nr_requests
+Lines: 1
+64
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/nr_zones
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/optimal_io_size
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/physical_block_size
+Lines: 1
+512
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/read_ahead_kb
+Lines: 1
+128
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/rotational
+Lines: 1
+1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/rq_affinity
+Lines: 1
+1
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/scheduler
+Lines: 1
+mq-deadline kyber [bfq] none
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/wbt_lat_usec
+Lines: 1
+75000
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/write_cache
+Lines: 1
+write back
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/write_same_max_bytes
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/write_zeroes_max_bytes
+Lines: 1
+0
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/block/sda/queue/zoned
+Lines: 1
+none
+Mode: 444
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/block/sda/stat
 Lines: 1
 9652963   396792 759304206   412943  8422549  6731723 286915323 13947418        0  5658367 19174573 1 2 3 12
@@ -2534,6 +3112,140 @@ Mode: 664
 Directory: fixtures/sys/class
 Mode: 775
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/sys/class/fc_host
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/sys/class/fc_host/host0
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/dev_loss_tmo
+Lines: 1
+30
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/fabric_name
+Lines: 1
+0x0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/node_name
+Lines: 1
+0x2000e0071bce95f2
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/port_id
+Lines: 1
+0x000002
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/port_name
+Lines: 1
+0x1000e0071bce95f2
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/port_state
+Lines: 1
+Online
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/port_type
+Lines: 1
+Point-To-Point (direct nport connection)
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/speed
+Lines: 1
+16 Gbit
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Directory: fixtures/sys/class/fc_host/host0/statistics
+Mode: 755
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/dumped_frames
+Lines: 1
+0xffffffffffffffff
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/error_frames
+Lines: 1
+0x0
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/fcp_packet_aborts
+Lines: 1
+0x13
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/invalid_crc_count
+Lines: 1
+0x2
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/invalid_tx_word_count
+Lines: 1
+0x8
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/link_failure_count
+Lines: 1
+0x9
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/loss_of_signal_count
+Lines: 1
+0x11
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/loss_of_sync_count
+Lines: 1
+0x10
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/nos_count
+Lines: 1
+0x12
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/rx_frames
+Lines: 1
+0x3
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/rx_words
+Lines: 1
+0x4
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/seconds_since_last_reset
+Lines: 1
+0x7
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/tx_frames
+Lines: 1
+0x5
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/statistics/tx_words
+Lines: 1
+0x6
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/supported_classes
+Lines: 1
+Class 3
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/supported_speeds
+Lines: 1
+4 Gbit, 8 Gbit, 16 Gbit
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/fc_host/host0/symbolic_name
+Lines: 1
+Emulex SN1100E2P FV12.4.270.3 DV12.4.0.0. HN:gotest. OS:Linux
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Directory: fixtures/sys/class/infiniband
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
@@ -2564,6 +3276,11 @@ Mode: 755
 Directory: fixtures/sys/class/infiniband/mlx4_0/ports/1/counters
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/infiniband/mlx4_0/ports/1/counters/VL15_dropped
+Lines: 1
+0
+Mode: 664
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/class/infiniband/mlx4_0/ports/1/counters/excessive_buffer_overrun_errors
 Lines: 1
 0
@@ -2665,6 +3382,11 @@ Mode: 755
 Directory: fixtures/sys/class/infiniband/mlx4_0/ports/2/counters
 Mode: 755
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/class/infiniband/mlx4_0/ports/2/counters/VL15_dropped
+Lines: 1
+0
+Mode: 664
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/class/infiniband/mlx4_0/ports/2/counters/excessive_buffer_overrun_errors
 Lines: 1
 0
@@ -3109,7 +3831,7 @@ Mode: 664
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/class/thermal/thermal_zone1/temp
 Lines: 1
-44000
+-44000
 Mode: 664
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/class/thermal/thermal_zone1/type
@@ -4287,6 +5009,17 @@ Lines: 1
 0
 Mode: 644
 # ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+Path: fixtures/sys/fs/bcache/deaddd54-c735-46d5-868e-f331c5fd7c74/bdev0/writeback_rate_debug
+Lines: 7
+rate:           1.1M/sec
+dirty:          20.4G
+target:         20.4G
+proportional:   427.5k
+integral:       790.0k
+change:         321.5k/sec
+next io:        17ms
+Mode: 644
+# ttar - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
 Path: fixtures/sys/fs/bcache/deaddd54-c735-46d5-868e-f331c5fd7c74/btree_cache_size
 Lines: 1
 0
diff --git a/vendor/github.com/prometheus/procfs/fscache.go b/vendor/github.com/prometheus/procfs/fscache.go
new file mode 100644
index 0000000..8783cf3
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/fscache.go
@@ -0,0 +1,422 @@
+// Copyright 2019 The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package procfs
+import (
+        "bufio"
+        "bytes"
+        "fmt"
+        "io"
+        "strconv"
+        "strings"
+        "github.com/prometheus/procfs/internal/util"
+)
+// Fscacheinfo represents fscache statistics.
+type Fscacheinfo struct {
+        // Number of index cookies allocated
+        IndexCookiesAllocated uint64
+        // data storage cookies allocated
+        DataStorageCookiesAllocated uint64
+        // Number of special cookies allocated
+        SpecialCookiesAllocated uint64
+        // Number of objects allocated
+        ObjectsAllocated uint64
+        // Number of object allocation failures
+        ObjectAllocationsFailure uint64
+        // Number of objects that reached the available state
+        ObjectsAvailable uint64
+        // Number of objects that reached the dead state
+        ObjectsDead uint64
+        // Number of objects that didn't have a coherency check
+        ObjectsWithoutCoherencyCheck uint64
+        // Number of objects that passed a coherency check
+        ObjectsWithCoherencyCheck uint64
+        // Number of objects that needed a coherency data update
+        ObjectsNeedCoherencyCheckUpdate uint64
+        // Number of objects that were declared obsolete
+        ObjectsDeclaredObsolete uint64
+        // Number of pages marked as being cached
+        PagesMarkedAsBeingCached uint64
+        // Number of uncache page requests seen
+        UncachePagesRequestSeen uint64
+        // Number of acquire cookie requests seen
+        AcquireCookiesRequestSeen uint64
+        // Number of acq reqs given a NULL parent
+        AcquireRequestsWithNullParent uint64
+        // Number of acq reqs rejected due to no cache available
+        AcquireRequestsRejectedNoCacheAvailable uint64
+        // Number of acq reqs succeeded
+        AcquireRequestsSucceeded uint64
+        // Number of acq reqs rejected due to error
+        AcquireRequestsRejectedDueToError uint64
+        // Number of acq reqs failed on ENOMEM
+        AcquireRequestsFailedDueToEnomem uint64
+        // Number of lookup calls made on cache backends
+        LookupsNumber uint64
+        // Number of negative lookups made
+        LookupsNegative uint64
+        // Number of positive lookups made
+        LookupsPositive uint64
+        // Number of objects created by lookup
+        ObjectsCreatedByLookup uint64
+        // Number of lookups timed out and requeued
+        LookupsTimedOutAndRequed uint64
+        InvalidationsNumber      uint64
+        InvalidationsRunning     uint64
+        // Number of update cookie requests seen
+        UpdateCookieRequestSeen uint64
+        // Number of upd reqs given a NULL parent
+        UpdateRequestsWithNullParent uint64
+        // Number of upd reqs granted CPU time
+        UpdateRequestsRunning uint64
+        // Number of relinquish cookie requests seen
+        RelinquishCookiesRequestSeen uint64
+        // Number of rlq reqs given a NULL parent
+        RelinquishCookiesWithNullParent uint64
+        // Number of rlq reqs waited on completion of creation
+        RelinquishRequestsWaitingCompleteCreation uint64
+        // Relinqs rtr
+        RelinquishRetries uint64
+        // Number of attribute changed requests seen
+        AttributeChangedRequestsSeen uint64
+        // Number of attr changed requests queued
+        AttributeChangedRequestsQueued uint64
+        // Number of attr changed rejected -ENOBUFS
+        AttributeChangedRejectDueToEnobufs uint64
+        // Number of attr changed failed -ENOMEM
+        AttributeChangedFailedDueToEnomem uint64
+        // Number of attr changed ops given CPU time
+        AttributeChangedOps uint64
+        // Number of allocation requests seen
+        AllocationRequestsSeen uint64
+        // Number of successful alloc reqs
+        AllocationOkRequests uint64
+        // Number of alloc reqs that waited on lookup completion
+        AllocationWaitingOnLookup uint64
+        // Number of alloc reqs rejected -ENOBUFS
+        AllocationsRejectedDueToEnobufs uint64
+        // Number of alloc reqs aborted -ERESTARTSYS
+        AllocationsAbortedDueToErestartsys uint64
+        // Number of alloc reqs submitted
+        AllocationOperationsSubmitted uint64
+        // Number of alloc reqs waited for CPU time
+        AllocationsWaitedForCPU uint64
+        // Number of alloc reqs aborted due to object death
+        AllocationsAbortedDueToObjectDeath uint64
+        // Number of retrieval (read) requests seen
+        RetrievalsReadRequests uint64
+        // Number of successful retr reqs
+        RetrievalsOk uint64
+        // Number of retr reqs that waited on lookup completion
+        RetrievalsWaitingLookupCompletion uint64
+        // Number of retr reqs returned -ENODATA
+        RetrievalsReturnedEnodata uint64
+        // Number of retr reqs rejected -ENOBUFS
+        RetrievalsRejectedDueToEnobufs uint64
+        // Number of retr reqs aborted -ERESTARTSYS
+        RetrievalsAbortedDueToErestartsys uint64
+        // Number of retr reqs failed -ENOMEM
+        RetrievalsFailedDueToEnomem uint64
+        // Number of retr reqs submitted
+        RetrievalsRequests uint64
+        // Number of retr reqs waited for CPU time
+        RetrievalsWaitingCPU uint64
+        // Number of retr reqs aborted due to object death
+        RetrievalsAbortedDueToObjectDeath uint64
+        // Number of storage (write) requests seen
+        StoreWriteRequests uint64
+        // Number of successful store reqs
+        StoreSuccessfulRequests uint64
+        // Number of store reqs on a page already pending storage
+        StoreRequestsOnPendingStorage uint64
+        // Number of store reqs rejected -ENOBUFS
+        StoreRequestsRejectedDueToEnobufs uint64
+        // Number of store reqs failed -ENOMEM
+        StoreRequestsFailedDueToEnomem uint64
+        // Number of store reqs submitted
+        StoreRequestsSubmitted uint64
+        // Number of store reqs granted CPU time
+        StoreRequestsRunning uint64
+        // Number of pages given store req processing time
+        StorePagesWithRequestsProcessing uint64
+        // Number of store reqs deleted from tracking tree
+        StoreRequestsDeleted uint64
+        // Number of store reqs over store limit
+        StoreRequestsOverStoreLimit uint64
+        // Number of release reqs against pages with no pending store
+        ReleaseRequestsAgainstPagesWithNoPendingStorage uint64
+        // Number of release reqs against pages stored by time lock granted
+        ReleaseRequestsAgainstPagesStoredByTimeLockGranted uint64
+        // Number of release reqs ignored due to in-progress store
+        ReleaseRequestsIgnoredDueToInProgressStore uint64
+        // Number of page stores cancelled due to release req
+        PageStoresCancelledByReleaseRequests uint64
+        VmscanWaiting                        uint64
+        // Number of times async ops added to pending queues
+        OpsPending uint64
+        // Number of times async ops given CPU time
+        OpsRunning uint64
+        // Number of times async ops queued for processing
+        OpsEnqueued uint64
+        // Number of async ops cancelled
+        OpsCancelled uint64
+        // Number of async ops rejected due to object lookup/create failure
+        OpsRejected uint64
+        // Number of async ops initialised
+        OpsInitialised uint64
+        // Number of async ops queued for deferred release
+        OpsDeferred uint64
+        // Number of async ops released (should equal ini=N when idle)
+        OpsReleased uint64
+        // Number of deferred-release async ops garbage collected
+        OpsGarbageCollected uint64
+        // Number of in-progress alloc_object() cache ops
+        CacheopAllocationsinProgress uint64
+        // Number of in-progress lookup_object() cache ops
+        CacheopLookupObjectInProgress uint64
+        // Number of in-progress lookup_complete() cache ops
+        CacheopLookupCompleteInPorgress uint64
+        // Number of in-progress grab_object() cache ops
+        CacheopGrabObjectInProgress uint64
+        CacheopInvalidations        uint64
+        // Number of in-progress update_object() cache ops
+        CacheopUpdateObjectInProgress uint64
+        // Number of in-progress drop_object() cache ops
+        CacheopDropObjectInProgress uint64
+        // Number of in-progress put_object() cache ops
+        CacheopPutObjectInProgress uint64
+        // Number of in-progress attr_changed() cache ops
+        CacheopAttributeChangeInProgress uint64
+        // Number of in-progress sync_cache() cache ops
+        CacheopSyncCacheInProgress uint64
+        // Number of in-progress read_or_alloc_page() cache ops
+        CacheopReadOrAllocPageInProgress uint64
+        // Number of in-progress read_or_alloc_pages() cache ops
+        CacheopReadOrAllocPagesInProgress uint64
+        // Number of in-progress allocate_page() cache ops
+        CacheopAllocatePageInProgress uint64
+        // Number of in-progress allocate_pages() cache ops
+        CacheopAllocatePagesInProgress uint64
+        // Number of in-progress write_page() cache ops
+        CacheopWritePagesInProgress uint64
+        // Number of in-progress uncache_page() cache ops
+        CacheopUncachePagesInProgress uint64
+        // Number of in-progress dissociate_pages() cache ops
+        CacheopDissociatePagesInProgress uint64
+        // Number of object lookups/creations rejected due to lack of space
+        CacheevLookupsAndCreationsRejectedLackSpace uint64
+        // Number of stale objects deleted
+        CacheevStaleObjectsDeleted uint64
+        // Number of objects retired when relinquished
+        CacheevRetiredWhenReliquished uint64
+        // Number of objects culled
+        CacheevObjectsCulled uint64
+}
+// Fscacheinfo returns information about current fscache statistics.
+// See https://www.kernel.org/doc/Documentation/filesystems/caching/fscache.txt
+func (fs FS) Fscacheinfo() (Fscacheinfo, error) {
+        b, err := util.ReadFileNoStat(fs.proc.Path("fs/fscache/stats"))
+        if err != nil {
+                return Fscacheinfo{}, err
+        }
+        m, err := parseFscacheinfo(bytes.NewReader(b))
+        if err != nil {
+                return Fscacheinfo{}, fmt.Errorf("failed to parse Fscacheinfo: %v", err)
+        }
+        return *m, nil
+}
+func setFSCacheFields(fields []string, setFields ...*uint64) error {
+        var err error
+        if len(fields) < len(setFields) {
+                return fmt.Errorf("Insufficient number of fields, expected %v, got %v", len(setFields), len(fields))
+        }
+        for i := range setFields {
+                *setFields[i], err = strconv.ParseUint(strings.Split(fields[i], "=")[1], 0, 64)
+                if err != nil {
+                        return err
+                }
+        }
+        return nil
+}
+func parseFscacheinfo(r io.Reader) (*Fscacheinfo, error) {
+        var m Fscacheinfo
+        s := bufio.NewScanner(r)
+        for s.Scan() {
+                fields := strings.Fields(s.Text())
+                if len(fields) < 2 {
+                        return nil, fmt.Errorf("malformed Fscacheinfo line: %q", s.Text())
+                }
+                switch fields[0] {
+                case "Cookies:":
+                        err := setFSCacheFields(fields[1:], &m.IndexCookiesAllocated, &m.DataStorageCookiesAllocated,
+                                &m.SpecialCookiesAllocated)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Objects:":
+                        err := setFSCacheFields(fields[1:], &m.ObjectsAllocated, &m.ObjectAllocationsFailure,
+                                &m.ObjectsAvailable, &m.ObjectsDead)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "ChkAux":
+                        err := setFSCacheFields(fields[2:], &m.ObjectsWithoutCoherencyCheck, &m.ObjectsWithCoherencyCheck,
+                                &m.ObjectsNeedCoherencyCheckUpdate, &m.ObjectsDeclaredObsolete)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Pages":
+                        err := setFSCacheFields(fields[2:], &m.PagesMarkedAsBeingCached, &m.UncachePagesRequestSeen)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Acquire:":
+                        err := setFSCacheFields(fields[1:], &m.AcquireCookiesRequestSeen, &m.AcquireRequestsWithNullParent,
+                                &m.AcquireRequestsRejectedNoCacheAvailable, &m.AcquireRequestsSucceeded, &m.AcquireRequestsRejectedDueToError,
+                                &m.AcquireRequestsFailedDueToEnomem)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Lookups:":
+                        err := setFSCacheFields(fields[1:], &m.LookupsNumber, &m.LookupsNegative, &m.LookupsPositive,
+                                &m.ObjectsCreatedByLookup, &m.LookupsTimedOutAndRequed)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Invals":
+                        err := setFSCacheFields(fields[2:], &m.InvalidationsNumber, &m.InvalidationsRunning)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Updates:":
+                        err := setFSCacheFields(fields[1:], &m.UpdateCookieRequestSeen, &m.UpdateRequestsWithNullParent,
+                                &m.UpdateRequestsRunning)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Relinqs:":
+                        err := setFSCacheFields(fields[1:], &m.RelinquishCookiesRequestSeen, &m.RelinquishCookiesWithNullParent,
+                                &m.RelinquishRequestsWaitingCompleteCreation, &m.RelinquishRetries)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "AttrChg:":
+                        err := setFSCacheFields(fields[1:], &m.AttributeChangedRequestsSeen, &m.AttributeChangedRequestsQueued,
+                                &m.AttributeChangedRejectDueToEnobufs, &m.AttributeChangedFailedDueToEnomem, &m.AttributeChangedOps)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Allocs":
+                        if strings.Split(fields[2], "=")[0] == "n" {
+                                err := setFSCacheFields(fields[2:], &m.AllocationRequestsSeen, &m.AllocationOkRequests,
+                                        &m.AllocationWaitingOnLookup, &m.AllocationsRejectedDueToEnobufs, &m.AllocationsAbortedDueToErestartsys)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else {
+                                err := setFSCacheFields(fields[2:], &m.AllocationOperationsSubmitted, &m.AllocationsWaitedForCPU,
+                                        &m.AllocationsAbortedDueToObjectDeath)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        }
+                case "Retrvls:":
+                        if strings.Split(fields[1], "=")[0] == "n" {
+                                err := setFSCacheFields(fields[1:], &m.RetrievalsReadRequests, &m.RetrievalsOk, &m.RetrievalsWaitingLookupCompletion,
+                                        &m.RetrievalsReturnedEnodata, &m.RetrievalsRejectedDueToEnobufs, &m.RetrievalsAbortedDueToErestartsys,
+                                        &m.RetrievalsFailedDueToEnomem)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else {
+                                err := setFSCacheFields(fields[1:], &m.RetrievalsRequests, &m.RetrievalsWaitingCPU, &m.RetrievalsAbortedDueToObjectDeath)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        }
+                case "Stores":
+                        if strings.Split(fields[2], "=")[0] == "n" {
+                                err := setFSCacheFields(fields[2:], &m.StoreWriteRequests, &m.StoreSuccessfulRequests,
+                                        &m.StoreRequestsOnPendingStorage, &m.StoreRequestsRejectedDueToEnobufs, &m.StoreRequestsFailedDueToEnomem)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else {
+                                err := setFSCacheFields(fields[2:], &m.StoreRequestsSubmitted, &m.StoreRequestsRunning,
+                                        &m.StorePagesWithRequestsProcessing, &m.StoreRequestsDeleted, &m.StoreRequestsOverStoreLimit)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        }
+                case "VmScan":
+                        err := setFSCacheFields(fields[2:], &m.ReleaseRequestsAgainstPagesWithNoPendingStorage,
+                                &m.ReleaseRequestsAgainstPagesStoredByTimeLockGranted, &m.ReleaseRequestsIgnoredDueToInProgressStore,
+                                &m.PageStoresCancelledByReleaseRequests, &m.VmscanWaiting)
+                        if err != nil {
+                                return &m, err
+                        }
+                case "Ops":
+                        if strings.Split(fields[2], "=")[0] == "pend" {
+                                err := setFSCacheFields(fields[2:], &m.OpsPending, &m.OpsRunning, &m.OpsEnqueued, &m.OpsCancelled, &m.OpsRejected)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else {
+                                err := setFSCacheFields(fields[2:], &m.OpsInitialised, &m.OpsDeferred, &m.OpsReleased, &m.OpsGarbageCollected)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        }
+                case "CacheOp:":
+                        if strings.Split(fields[1], "=")[0] == "alo" {
+                                err := setFSCacheFields(fields[1:], &m.CacheopAllocationsinProgress, &m.CacheopLookupObjectInProgress,
+                                        &m.CacheopLookupCompleteInPorgress, &m.CacheopGrabObjectInProgress)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else if strings.Split(fields[1], "=")[0] == "inv" {
+                                err := setFSCacheFields(fields[1:], &m.CacheopInvalidations, &m.CacheopUpdateObjectInProgress,
+                                        &m.CacheopDropObjectInProgress, &m.CacheopPutObjectInProgress, &m.CacheopAttributeChangeInProgress,
+                                        &m.CacheopSyncCacheInProgress)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        } else {
+                                err := setFSCacheFields(fields[1:], &m.CacheopReadOrAllocPageInProgress, &m.CacheopReadOrAllocPagesInProgress,
+                                        &m.CacheopAllocatePageInProgress, &m.CacheopAllocatePagesInProgress, &m.CacheopWritePagesInProgress,
+                                        &m.CacheopUncachePagesInProgress, &m.CacheopDissociatePagesInProgress)
+                                if err != nil {
+                                        return &m, err
+                                }
+                        }
+                case "CacheEv:":
+                        err := setFSCacheFields(fields[1:], &m.CacheevLookupsAndCreationsRejectedLackSpace, &m.CacheevStaleObjectsDeleted,
+                                &m.CacheevRetiredWhenReliquished, &m.CacheevObjectsCulled)
+                        if err != nil {
+                                return &m, err
+                        }
+                }
+        }
+        return &m, nil
+}
diff --git a/vendor/github.com/prometheus/procfs/internal/util/parse.go b/vendor/github.com/prometheus/procfs/internal/util/parse.go
index 755591d..22cb07a 100644
--- a/vendor/github.com/prometheus/procfs/internal/util/parse.go
+++ b/vendor/github.com/prometheus/procfs/internal/util/parse.go
@@ -73,6 +73,15 @@ func ReadUintFromFile(path string) (uint64, error) {
        return strconv.ParseUint(strings.TrimSpace(string(data)), 10, 64)
 }
+// ReadIntFromFile reads a file and attempts to parse a int64 from it.
+func ReadIntFromFile(path string) (int64, error) {
+        data, err := ioutil.ReadFile(path)
+        if err != nil {
+                return 0, err
+        }
+        return strconv.ParseInt(strings.TrimSpace(string(data)), 10, 64)
+}
 // ParseBool parses a string into a boolean pointer.
 func ParseBool(b string) *bool {
        var truth bool
diff --git a/vendor/github.com/prometheus/procfs/kernel_random.go b/vendor/github.com/prometheus/procfs/kernel_random.go
new file mode 100644
index 0000000..beefdf0
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/kernel_random.go
@@ -0,0 +1,62 @@
+// Copyright 2020 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.
+// +build !windows
+package procfs
+import (
+        "os"
+        "github.com/prometheus/procfs/internal/util"
+)
+// KernelRandom contains information about to the kernel's random number generator.
+type KernelRandom struct {
+        // EntropyAvaliable gives the available entropy, in bits.
+        EntropyAvaliable *uint64
+        // PoolSize gives the size of the entropy pool, in bytes.
+        PoolSize *uint64
+        // URandomMinReseedSeconds is the number of seconds after which the DRNG will be reseeded.
+        URandomMinReseedSeconds *uint64
+        // WriteWakeupThreshold the number of bits of entropy below which we wake up processes
+        // that do a select(2) or poll(2) for write access to /dev/random.
+        WriteWakeupThreshold *uint64
+        // ReadWakeupThreshold is the number of bits of entropy required for waking up processes that sleep
+        // waiting for entropy from /dev/random.
+        ReadWakeupThreshold *uint64
+}
+// KernelRandom returns values from /proc/sys/kernel/random.
+func (fs FS) KernelRandom() (KernelRandom, error) {
+        random := KernelRandom{}
+        for file, p := range map[string]**uint64{
+                "entropy_avail":           &random.EntropyAvaliable,
+                "poolsize":                &random.PoolSize,
+                "urandom_min_reseed_secs": &random.URandomMinReseedSeconds,
+                "write_wakeup_threshold":  &random.WriteWakeupThreshold,
+                "read_wakeup_threshold":   &random.ReadWakeupThreshold,
+        } {
+                val, err := util.ReadUintFromFile(fs.proc.Path("sys", "kernel", "random", file))
+                if os.IsNotExist(err) {
+                        continue
+                }
+                if err != nil {
+                        return random, err
+                }
+                *p = &val
+        }
+        return random, nil
+}
diff --git a/vendor/github.com/prometheus/procfs/mdstat.go b/vendor/github.com/prometheus/procfs/mdstat.go
index 2af3ada..3e9362a 100644
--- a/vendor/github.com/prometheus/procfs/mdstat.go
+++ b/vendor/github.com/prometheus/procfs/mdstat.go
@@ -52,7 +52,7 @@ type MDStat struct {
 func (fs FS) MDStat() ([]MDStat, error) {
        data, err := ioutil.ReadFile(fs.proc.Path("mdstat"))
        if err != nil {
-                return nil, fmt.Errorf("error parsing mdstat %s: %s", fs.proc.Path("mdstat"), err)
+                return nil, err
        }
        mdstat, err := parseMDStat(data)
        if err != nil {
diff --git a/vendor/github.com/prometheus/procfs/mountinfo.go b/vendor/github.com/prometheus/procfs/mountinfo.go
index 9471136..59f4d50 100644
--- a/vendor/github.com/prometheus/procfs/mountinfo.go
+++ b/vendor/github.com/prometheus/procfs/mountinfo.go
@@ -77,7 +77,7 @@ func parseMountInfoString(mountString string) (*MountInfo, error) {
        mountInfo := strings.Split(mountString, " ")
        mountInfoLength := len(mountInfo)
-        if mountInfoLength < 11 {
+        if mountInfoLength < 10 {
                return nil, fmt.Errorf("couldn't find enough fields in mount string: %s", mountString)
        }
@@ -144,7 +144,7 @@ func mountOptionsParseOptionalFields(o []string) (map[string]string, error) {
        return optionalFields, nil
 }
-// Parses the mount options, superblock options.
+// mountOptionsParser parses the mount options, superblock options.
 func mountOptionsParser(mountOptions string) map[string]string {
        opts := make(map[string]string)
        options := strings.Split(mountOptions, ",")
@@ -161,7 +161,7 @@ func mountOptionsParser(mountOptions string) map[string]string {
        return opts
 }
-// Retrieves mountinfo information from `/proc/self/mountinfo`.
+// GetMounts retrieves mountinfo information from `/proc/self/mountinfo`.
 func GetMounts() ([]*MountInfo, error) {
        data, err := util.ReadFileNoStat("/proc/self/mountinfo")
        if err != nil {
@@ -170,7 +170,7 @@ func GetMounts() ([]*MountInfo, error) {
        return parseMountInfo(data)
 }
-// Retrieves mountinfo information from a processes' `/proc/<pid>/mountinfo`.
+// GetProcMounts retrieves mountinfo information from a processes' `/proc/<pid>/mountinfo`.
 func GetProcMounts(pid int) ([]*MountInfo, error) {
        data, err := util.ReadFileNoStat(fmt.Sprintf("/proc/%d/mountinfo", pid))
        if err != nil {
diff --git a/vendor/github.com/prometheus/procfs/mountstats.go b/vendor/github.com/prometheus/procfs/mountstats.go
index 35b2ef3..861ced9 100644
--- a/vendor/github.com/prometheus/procfs/mountstats.go
+++ b/vendor/github.com/prometheus/procfs/mountstats.go
@@ -186,6 +186,8 @@ type NFSOperationStats struct {
        CumulativeTotalResponseMilliseconds uint64
        // Duration from when a request was enqueued to when it was completely handled.
        CumulativeTotalRequestMilliseconds uint64
+        // The count of operations that complete with tk_status < 0.  These statuses usually indicate error conditions.
+        Errors uint64
 }
 // A NFSTransportStats contains statistics for the NFS mount RPC requests and
@@ -494,8 +496,8 @@ func parseNFSEventsStats(ss []string) (*NFSEventsStats, error) {
 // line is reached.
 func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
        const (
-                // Number of expected fields in each per-operation statistics set
+                // Minimum number of expected fields in each per-operation statistics set
-                numFields = 9
+                minFields = 9
        )
        var ops []NFSOperationStats
@@ -508,12 +510,12 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
                        break
                }
-                if len(ss) != numFields {
+                if len(ss) < minFields {
                        return nil, fmt.Errorf("invalid NFS per-operations stats: %v", ss)
                }
                // Skip string operation name for integers
-                ns := make([]uint64, 0, numFields-1)
+                ns := make([]uint64, 0, minFields-1)
                for _, st := range ss[1:] {
                        n, err := strconv.ParseUint(st, 10, 64)
                        if err != nil {
@@ -523,7 +525,7 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
                        ns = append(ns, n)
                }
-                ops = append(ops, NFSOperationStats{
+                opStats := NFSOperationStats{
                        Operation:                           strings.TrimSuffix(ss[0], ":"),
                        Requests:                            ns[0],
                        Transmissions:                       ns[1],
@@ -533,7 +535,13 @@ func parseNFSOperationStats(s *bufio.Scanner) ([]NFSOperationStats, error) {
                        CumulativeQueueMilliseconds:         ns[5],
                        CumulativeTotalResponseMilliseconds: ns[6],
                        CumulativeTotalRequestMilliseconds:  ns[7],
-                })
+                }
+                if len(ns) > 8 {
+                        opStats.Errors = ns[8]
+                }
+                ops = append(ops, opStats)
        }
        return ops, s.Err()
diff --git a/vendor/github.com/prometheus/procfs/net_conntrackstat.go b/vendor/github.com/prometheus/procfs/net_conntrackstat.go
index 1e27c83..b637be9 100644
--- a/vendor/github.com/prometheus/procfs/net_conntrackstat.go
+++ b/vendor/github.com/prometheus/procfs/net_conntrackstat.go
@@ -38,7 +38,7 @@ type ConntrackStatEntry struct {
        SearchRestart uint64
 }
-// Retrieves netfilter's conntrack statistics, split by CPU cores
+// ConntrackStat retrieves netfilter's conntrack statistics, split by CPU cores
 func (fs FS) ConntrackStat() ([]ConntrackStatEntry, error) {
        return readConntrackStat(fs.proc.Path("net", "stat", "nf_conntrack"))
 }
diff --git a/vendor/github.com/prometheus/procfs/proc.go b/vendor/github.com/prometheus/procfs/proc.go
index 330e472..9f97b6e 100644
--- a/vendor/github.com/prometheus/procfs/proc.go
+++ b/vendor/github.com/prometheus/procfs/proc.go
@@ -134,6 +134,27 @@ func (p Proc) CmdLine() ([]string, error) {
        return strings.Split(string(bytes.TrimRight(data, string("\x00"))), string(byte(0))), nil
 }
+// Wchan returns the wchan (wait channel) of a process.
+func (p Proc) Wchan() (string, error) {
+        f, err := os.Open(p.path("wchan"))
+        if err != nil {
+                return "", err
+        }
+        defer f.Close()
+        data, err := ioutil.ReadAll(f)
+        if err != nil {
+                return "", err
+        }
+        wchan := string(data)
+        if wchan == "" || wchan == "0" {
+                return "", nil
+        }
+        return wchan, nil
+}
 // Comm returns the command name of a process.
 func (p Proc) Comm() (string, error) {
        data, err := util.ReadFileNoStat(p.path("comm"))
diff --git a/vendor/github.com/prometheus/procfs/proc_cgroup.go b/vendor/github.com/prometheus/procfs/proc_cgroup.go
new file mode 100644
index 0000000..4abd464
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/proc_cgroup.go
@@ -0,0 +1,98 @@
+// Copyright 2020 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"
+        "strconv"
+        "strings"
+        "github.com/prometheus/procfs/internal/util"
+)
+// Cgroup models one line from /proc/[pid]/cgroup. Each Cgroup struct describes the the placement of a PID inside a
+// 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
+// *this specific* hierarchy, you can locate the relevant pseudo-files needed to read/set the data for this PID
+// in this hierarchy
+//
+// Also see http://man7.org/linux/man-pages/man7/cgroups.7.html
+type Cgroup struct {
+        // HierarchyID that can be matched to a named hierarchy using /proc/cgroups. Cgroups V2 only has one
+        // hierarchy, so HierarchyID is always 0. For cgroups v1 this is a unique ID number
+        HierarchyID int
+        // Controllers using this hierarchy of processes. Controllers are also known as subsystems. For
+        // Cgroups V2 this may be empty, as all active controllers use the same hierarchy
+        Controllers []string
+        // Path of this control group, relative to the mount point of the cgroupfs representing this specific
+        // hierarchy
+        Path string
+}
+// parseCgroupString parses each line of the /proc/[pid]/cgroup file
+// Line format is hierarchyID:[controller1,controller2]:path
+func parseCgroupString(cgroupStr string) (*Cgroup, error) {
+        var err error
+        fields := strings.Split(cgroupStr, ":")
+        if len(fields) < 3 {
+                return nil, fmt.Errorf("at least 3 fields required, found %d fields in cgroup string: %s", len(fields), cgroupStr)
+        }
+        cgroup := &Cgroup{
+                Path:        fields[2],
+                Controllers: nil,
+        }
+        cgroup.HierarchyID, err = strconv.Atoi(fields[0])
+        if err != nil {
+                return nil, fmt.Errorf("failed to parse hierarchy ID")
+        }
+        if fields[1] != "" {
+                ssNames := strings.Split(fields[1], ",")
+                cgroup.Controllers = append(cgroup.Controllers, ssNames...)
+        }
+        return cgroup, nil
+}
+// parseCgroups reads each line of the /proc/[pid]/cgroup file
+func parseCgroups(data []byte) ([]Cgroup, error) {
+        var cgroups []Cgroup
+        scanner := bufio.NewScanner(bytes.NewReader(data))
+        for scanner.Scan() {
+                mountString := scanner.Text()
+                parsedMounts, err := parseCgroupString(mountString)
+                if err != nil {
+                        return nil, err
+                }
+                cgroups = append(cgroups, *parsedMounts)
+        }
+        err := scanner.Err()
+        return cgroups, err
+}
+// Cgroups reads from /proc/<pid>/cgroups and returns a []*Cgroup struct locating this PID in each process
+// control hierarchy running on this system. On every system (v1 and v2), all hierarchies contain all processes,
+// so the len of the returned struct is equal to the number of active hierarchies on this system
+func (p Proc) Cgroups() ([]Cgroup, error) {
+        data, err := util.ReadFileNoStat(fmt.Sprintf("/proc/%d/cgroup", p.PID))
+        if err != nil {
+                return nil, err
+        }
+        return parseCgroups(data)
+}
diff --git a/vendor/github.com/prometheus/procfs/proc_fdinfo.go b/vendor/github.com/prometheus/procfs/proc_fdinfo.go
index 0c9c402..a76ca70 100644
--- a/vendor/github.com/prometheus/procfs/proc_fdinfo.go
+++ b/vendor/github.com/prometheus/procfs/proc_fdinfo.go
@@ -41,7 +41,7 @@ type ProcFDInfo struct {
        Flags string
        // Mount point ID
        MntID string
-        // List of inotify lines (structed) in the fdinfo file (kernel 3.8+ only)
+        // List of inotify lines (structured) in the fdinfo file (kernel 3.8+ only)
        InotifyInfos []InotifyInfo
 }
diff --git a/vendor/github.com/prometheus/procfs/proc_maps.go b/vendor/github.com/prometheus/procfs/proc_maps.go
index 28d5c6e..1d7772d 100644
--- a/vendor/github.com/prometheus/procfs/proc_maps.go
+++ b/vendor/github.com/prometheus/procfs/proc_maps.go
@@ -11,7 +11,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
-// +build !windows
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 package procfs
@@ -25,6 +25,7 @@ import (
        "golang.org/x/sys/unix"
 )
+// ProcMapPermissions contains permission settings read from /proc/[pid]/maps
 type ProcMapPermissions struct {
        // mapping has the [R]ead flag set
        Read bool
diff --git a/vendor/github.com/prometheus/procfs/proc_smaps.go b/vendor/github.com/prometheus/procfs/proc_smaps.go
new file mode 100644
index 0000000..a576a72
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/proc_smaps.go
@@ -0,0 +1,165 @@
+// Copyright 2020 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.
+// +build !windows
+package procfs
+import (
+        "bufio"
+        "errors"
+        "fmt"
+        "os"
+        "regexp"
+        "strconv"
+        "strings"
+        "github.com/prometheus/procfs/internal/util"
+)
+var (
+        // match the header line before each mapped zone in /proc/pid/smaps
+        procSMapsHeaderLine = regexp.MustCompile(`^[a-f0-9].*$`)
+)
+type ProcSMapsRollup struct {
+        // Amount of the mapping that is currently resident in RAM
+        Rss uint64
+        // Process's proportional share of this mapping
+        Pss uint64
+        // Size in bytes of clean shared pages
+        SharedClean uint64
+        // Size in bytes of dirty shared pages
+        SharedDirty uint64
+        // Size in bytes of clean private pages
+        PrivateClean uint64
+        // Size in bytes of dirty private pages
+        PrivateDirty uint64
+        // Amount of memory currently marked as referenced or accessed
+        Referenced uint64
+        // Amount of memory that does not belong to any file
+        Anonymous uint64
+        // Amount would-be-anonymous memory currently on swap
+        Swap uint64
+        // Process's proportional memory on swap
+        SwapPss uint64
+}
+// ProcSMapsRollup reads from /proc/[pid]/smaps_rollup to get summed memory information of the
+// process.
+//
+// If smaps_rollup does not exists (require kernel >= 4.15), the content of /proc/pid/smaps will
+// we read and summed.
+func (p Proc) ProcSMapsRollup() (ProcSMapsRollup, error) {
+        data, err := util.ReadFileNoStat(p.path("smaps_rollup"))
+        if err != nil && os.IsNotExist(err) {
+                return p.procSMapsRollupManual()
+        }
+        if err != nil {
+                return ProcSMapsRollup{}, err
+        }
+        lines := strings.Split(string(data), "\n")
+        smaps := ProcSMapsRollup{}
+        // skip first line which don't contains information we need
+        lines = lines[1:]
+        for _, line := range lines {
+                if line == "" {
+                        continue
+                }
+                if err := smaps.parseLine(line); err != nil {
+                        return ProcSMapsRollup{}, err
+                }
+        }
+        return smaps, nil
+}
+// Read /proc/pid/smaps and do the roll-up in Go code.
+func (p Proc) procSMapsRollupManual() (ProcSMapsRollup, error) {
+        file, err := os.Open(p.path("smaps"))
+        if err != nil {
+                return ProcSMapsRollup{}, err
+        }
+        defer file.Close()
+        smaps := ProcSMapsRollup{}
+        scan := bufio.NewScanner(file)
+        for scan.Scan() {
+                line := scan.Text()
+                if procSMapsHeaderLine.MatchString(line) {
+                        continue
+                }
+                if err := smaps.parseLine(line); err != nil {
+                        return ProcSMapsRollup{}, err
+                }
+        }
+        return smaps, nil
+}
+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")
+        }
+        k := kv[0]
+        if k == "VmFlags" {
+                return nil
+        }
+        v := strings.TrimSpace(kv[1])
+        v = strings.TrimRight(v, " kB")
+        vKBytes, err := strconv.ParseUint(v, 10, 64)
+        if err != nil {
+                return err
+        }
+        vBytes := vKBytes * 1024
+        s.addValue(k, v, vKBytes, vBytes)
+        return nil
+}
+func (s *ProcSMapsRollup) addValue(k string, vString string, vUint uint64, vUintBytes uint64) {
+        switch k {
+        case "Rss":
+                s.Rss += vUintBytes
+        case "Pss":
+                s.Pss += vUintBytes
+        case "Shared_Clean":
+                s.SharedClean += vUintBytes
+        case "Shared_Dirty":
+                s.SharedDirty += vUintBytes
+        case "Private_Clean":
+                s.PrivateClean += vUintBytes
+        case "Private_Dirty":
+                s.PrivateDirty += vUintBytes
+        case "Referenced":
+                s.Referenced += vUintBytes
+        case "Anonymous":
+                s.Anonymous += vUintBytes
+        case "Swap":
+                s.Swap += vUintBytes
+        case "SwapPss":
+                s.SwapPss += vUintBytes
+        }
+}
diff --git a/vendor/github.com/prometheus/procfs/sysfs/class_fibrechannel.go b/vendor/github.com/prometheus/procfs/sysfs/class_fibrechannel.go
new file mode 100644
index 0000000..d57ff9c
--- /dev/null
+++ b/vendor/github.com/prometheus/procfs/sysfs/class_fibrechannel.go
@@ -0,0 +1,249 @@
+// Copyright 2020 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.
+// +build !windows
+package sysfs
+import (
+        "fmt"
+        "io/ioutil"
+        "os"
+        "path/filepath"
+        "github.com/prometheus/procfs/internal/util"
+)
+const fibrechannelClassPath = "class/fc_host"
+type FibreChannelCounters struct {
+        DumpedFrames          uint64 // /sys/class/fc_host/<Name>/statistics/dumped_frames
+        ErrorFrames           uint64 // /sys/class/fc_host/<Name>/statistics/error_frames
+        InvalidCRCCount       uint64 // /sys/class/fc_host/<Name>/statistics/invalid_crc_count
+        RXFrames              uint64 // /sys/class/fc_host/<Name>/statistics/rx_frames
+        RXWords               uint64 // /sys/class/fc_host/<Name>/statistics/rx_words
+        TXFrames              uint64 // /sys/class/fc_host/<Name>/statistics/tx_frames
+        TXWords               uint64 // /sys/class/fc_host/<Name>/statistics/tx_words
+        SecondsSinceLastReset uint64 // /sys/class/fc_host/<Name>/statistics/seconds_since_last_reset
+        InvalidTXWordCount    uint64 // /sys/class/fc_host/<Name>/statistics/invalid_tx_word_count
+        LinkFailureCount      uint64 // /sys/class/fc_host/<Name>/statistics/link_failure_count
+        LossOfSyncCount       uint64 // /sys/class/fc_host/<Name>/statistics/loss_of_sync_count
+        LossOfSignalCount     uint64 // /sys/class/fc_host/<Name>/statistics/loss_of_signal_count
+        NosCount              uint64 // /sys/class/fc_host/<Name>/statistics/nos_count
+        FCPPacketAborts       uint64 // / sys/class/fc_host/<Name>/statistics/fcp_packet_aborts
+}
+type FibreChannelHost struct {
+        Name             string               // /sys/class/fc_host/<Name>
+        Speed            string               // /sys/class/fc_host/<Name>/speed
+        PortState        string               // /sys/class/fc_host/<Name>/port_state
+        PortType         string               // /sys/class/fc_host/<Name>/port_type
+        SymbolicName     string               // /sys/class/fc_host/<Name>/symbolic_name
+        NodeName         string               // /sys/class/fc_host/<Name>/node_name
+        PortID           string               // /sys/class/fc_host/<Name>/port_id
+        PortName         string               // /sys/class/fc_host/<Name>/port_name
+        FabricName       string               // /sys/class/fc_host/<Name>/fabric_name
+        DevLossTMO       string               // /sys/class/fc_host/<Name>/dev_loss_tmo
+        SupportedClasses string               // /sys/class/fc_host/<Name>/supported_classes
+        SupportedSpeeds  string               // /sys/class/fc_host/<Name>/supported_speeds
+        Counters         FibreChannelCounters // /sys/class/fc_host/<Name>/statistics/*
+}
+type FibreChannelClass map[string]FibreChannelHost
+// FibreChannelClass parses everything in /sys/class/fc_host.
+func (fs FS) FibreChannelClass() (FibreChannelClass, error) {
+        path := fs.sys.Path(fibrechannelClassPath)
+        dirs, err := ioutil.ReadDir(path)
+        if err != nil {
+                return nil, err
+        }
+        fcc := make(FibreChannelClass, len(dirs))
+        for _, d := range dirs {
+                host, err := fs.parseFibreChannelHost(d.Name())
+                if err != nil {
+                        return nil, err
+                }
+                fcc[host.Name] = *host
+        }
+        return fcc, nil
+}
+// Parse a single FC host
+func (fs FS) parseFibreChannelHost(name string) (*FibreChannelHost, error) {
+        path := fs.sys.Path(fibrechannelClassPath, name)
+        host := FibreChannelHost{Name: name}
+        for _, f := range [...]string{"speed", "port_state", "port_type", "node_name", "port_id", "port_name", "fabric_name", "dev_loss_tmo", "symbolic_name", "supported_classes", "supported_speeds"} {
+                name := filepath.Join(path, f)
+                value, err := util.SysReadFile(name)
+                if err != nil {
+                        return nil, fmt.Errorf("failed to read file %q: %v", name, err)
+                }
+                switch f {
+                case "speed":
+                        host.Speed = value
+                case "port_state":
+                        host.PortState = value
+                case "port_type":
+                        host.PortType = value
+                case "node_name":
+                        if len(value) > 2 {
+                                value = value[2:]
+                        }
+                        host.NodeName = value
+                case "port_id":
+                        if len(value) > 2 {
+                                value = value[2:]
+                        }
+                        host.PortID = value
+                case "port_name":
+                        if len(value) > 2 {
+                                value = value[2:]
+                        }
+                        host.PortName = value
+                case "fabric_name":
+                        if len(value) > 2 {
+                                value = value[2:]
+                        }
+                        host.FabricName = value
+                case "dev_loss_tmo":
+                        host.DevLossTMO = value
+                case "supported_classes":
+                        host.SupportedClasses = value
+                case "supported_speeds":
+                        host.SupportedSpeeds = value
+                case "symbolic_name":
+                        host.SymbolicName = value
+                }
+        }
+        counters, err := parseFibreChannelStatistics(path)
+        if err != nil {
+                return nil, err
+        }
+        host.Counters = *counters
+        return &host, nil
+}
+// parseFibreChannelStatistics parses metrics from a single FC host.
+func parseFibreChannelStatistics(hostPath string) (*FibreChannelCounters, error) {
+        var counters FibreChannelCounters
+        path := filepath.Join(hostPath, "statistics")
+        files, err := ioutil.ReadDir(path)
+        if err != nil {
+                return nil, err
+        }
+        for _, f := range files {
+                if !f.Mode().IsRegular() || f.Name() == "reset_statistics" {
+                        continue
+                }
+                name := filepath.Join(path, f.Name())
+                value, err := util.SysReadFile(name)
+                if err != nil {
+                        // there are some write-only files in this directory; we can safely skip over them
+                        if os.IsNotExist(err) || err.Error() == "operation not supported" || err.Error() == "invalid argument" {
+                                continue
+                        }
+                        return nil, fmt.Errorf("failed to read file %q: %v", name, err)
+                }
+                vp := util.NewValueParser(value)
+                // Below switch was automatically generated. Don't need everything in there yet, so the unwanted bits are commented out.
+                switch f.Name() {
+                case "dumped_frames":
+                        counters.DumpedFrames = *vp.PUInt64()
+                case "error_frames":
+                        counters.ErrorFrames = *vp.PUInt64()
+                /*
+                        case "fc_no_free_exch":
+                                counters.FcNoFreeExch = *vp.PUInt64()
+                        case "fc_no_free_exch_xid":
+                                counters.FcNoFreeExchXid = *vp.PUInt64()
+                        case "fc_non_bls_resp":
+                                counters.FcNonBlsResp = *vp.PUInt64()
+                        case "fc_seq_not_found":
+                                counters.FcSeqNotFound = *vp.PUInt64()
+                        case "fc_xid_busy":
+                                counters.FcXidBusy = *vp.PUInt64()
+                        case "fc_xid_not_found":
+                                counters.FcXidNotFound = *vp.PUInt64()
+                        case "fcp_control_requests":
+                                counters.FcpControlRequests = *vp.PUInt64()
+                        case "fcp_frame_alloc_failures":
+                                counters.FcpFrameAllocFailures = *vp.PUInt64()
+                        case "fcp_input_megabytes":
+                                counters.FcpInputMegabytes = *vp.PUInt64()
+                        case "fcp_input_requests":
+                                counters.FcpInputRequests = *vp.PUInt64()
+                        case "fcp_output_megabytes":
+                                counters.FcpOutputMegabytes = *vp.PUInt64()
+                        case "fcp_output_requests":
+                                counters.FcpOutputRequests = *vp.PUInt64()
+                */
+                case "fcp_packet_aborts":
+                        counters.FCPPacketAborts = *vp.PUInt64()
+                        /*
+                                case "fcp_packet_alloc_failures":
+                                        counters.FcpPacketAllocFailures = *vp.PUInt64()
+                        */
+                case "invalid_tx_word_count":
+                        counters.InvalidTXWordCount = *vp.PUInt64()
+                case "invalid_crc_count":
+                        counters.InvalidCRCCount = *vp.PUInt64()
+                case "link_failure_count":
+                        counters.LinkFailureCount = *vp.PUInt64()
+                /*
+                        case "lip_count":
+                                        counters.LipCount = *vp.PUInt64()
+                */
+                case "loss_of_signal_count":
+                        counters.LossOfSignalCount = *vp.PUInt64()
+                case "loss_of_sync_count":
+                        counters.LossOfSyncCount = *vp.PUInt64()
+                case "nos_count":
+                        counters.NosCount = *vp.PUInt64()
+                /*
+                        case "prim_seq_protocol_err_count":
+                                counters.PrimSeqProtocolErrCount = *vp.PUInt64()
+                */
+                case "rx_frames":
+                        counters.RXFrames = *vp.PUInt64()
+                case "rx_words":
+                        counters.RXWords = *vp.PUInt64()
+                case "seconds_since_last_reset":
+                        counters.SecondsSinceLastReset = *vp.PUInt64()
+                case "tx_frames":
+                        counters.TXFrames = *vp.PUInt64()
+                case "tx_words":
+                        counters.TXWords = *vp.PUInt64()
+                }
+                if err := vp.Err(); err != nil {
+                        return nil, err
+                }
+        }
+        return &counters, nil
+}
diff --git a/vendor/github.com/prometheus/procfs/sysfs/class_infiniband.go b/vendor/github.com/prometheus/procfs/sysfs/class_infiniband.go
index be900fa..0826e1c 100644
--- a/vendor/github.com/prometheus/procfs/sysfs/class_infiniband.go
+++ b/vendor/github.com/prometheus/procfs/sysfs/class_infiniband.go
@@ -42,22 +42,26 @@ type InfiniBandCounters struct {
        LegacyPortXmitData64           *uint64 // counters_ext/port_xmit_data_64
        LegacyPortXmitPackets64        *uint64 // counters_ext/port_xmit_packets_64
-        LinkDowned               *uint64 // counters/link_downed
+        LinkDowned                  *uint64 // counters/link_downed
-        LinkErrorRecovery        *uint64 // counters/link_error_recovery
+        LinkErrorRecovery           *uint64 // counters/link_error_recovery
-        MulticastRcvPackets      *uint64 // counters/multicast_rcv_packets
+        MulticastRcvPackets         *uint64 // counters/multicast_rcv_packets
-        MulticastXmitPackets     *uint64 // counters/multicast_xmit_packets
+        MulticastXmitPackets        *uint64 // counters/multicast_xmit_packets
-        PortRcvConstraintErrors  *uint64 // counters/port_rcv_constraint_errors
+        PortRcvConstraintErrors     *uint64 // counters/port_rcv_constraint_errors
-        PortRcvData              *uint64 // counters/port_rcv_data
+        PortRcvData                 *uint64 // counters/port_rcv_data
-        PortRcvDiscards          *uint64 // counters/port_rcv_discards
+        PortRcvDiscards             *uint64 // counters/port_rcv_discards
-        PortRcvErrors            *uint64 // counters/port_rcv_errors
+        PortRcvErrors               *uint64 // counters/port_rcv_errors
-        PortRcvPackets           *uint64 // counters/port_rcv_packets
+        PortRcvPackets              *uint64 // counters/port_rcv_packets
-        PortXmitConstraintErrors *uint64 // counters/port_xmit_constraint_errors
+        PortRcvRemotePhysicalErrors *uint64 // counters/port_rcv_remote_physical_errors
-        PortXmitData             *uint64 // counters/port_xmit_data
+        PortRcvSwitchRelayErrors    *uint64 // counters/port_rcv_switch_relay_errors
-        PortXmitDiscards         *uint64 // counters/port_xmit_discards
+        PortXmitConstraintErrors    *uint64 // counters/port_xmit_constraint_errors
-        PortXmitPackets          *uint64 // counters/port_xmit_packets
+        PortXmitData                *uint64 // counters/port_xmit_data
-        PortXmitWait             *uint64 // counters/port_xmit_wait
+        PortXmitDiscards            *uint64 // counters/port_xmit_discards
-        UnicastRcvPackets        *uint64 // counters/unicast_rcv_packets
+        PortXmitPackets             *uint64 // counters/port_xmit_packets
-        UnicastXmitPackets       *uint64 // counters/unicast_xmit_packets
+        PortXmitWait                *uint64 // counters/port_xmit_wait
+        SymbolError                 *uint64 // counters/symbol_error
+        UnicastRcvPackets           *uint64 // counters/unicast_rcv_packets
+        UnicastXmitPackets          *uint64 // counters/unicast_xmit_packets
+        VL15Dropped                 *uint64 // counters/VL15_dropped
 }
 // InfiniBandPort contains info from files in
@@ -287,6 +291,10 @@ func parseInfiniBandCounters(portPath string) (*InfiniBandCounters, error) {
                        counters.PortRcvErrors = vp.PUInt64()
                case "port_rcv_packets":
                        counters.PortRcvPackets = vp.PUInt64()
+                case "port_rcv_remote_physical_errors":
+                        counters.PortRcvRemotePhysicalErrors = vp.PUInt64()
+                case "port_rcv_switch_relay_errors":
+                        counters.PortRcvSwitchRelayErrors = vp.PUInt64()
                case "port_xmit_constraint_errors":
                        counters.PortXmitConstraintErrors = vp.PUInt64()
                case "port_xmit_data":
@@ -300,10 +308,14 @@ func parseInfiniBandCounters(portPath string) (*InfiniBandCounters, error) {
                        counters.PortXmitPackets = vp.PUInt64()
                case "port_xmit_wait":
                        counters.PortXmitWait = vp.PUInt64()
+                case "symbol_error":
+                        counters.SymbolError = vp.PUInt64()
                case "unicast_rcv_packets":
                        counters.UnicastRcvPackets = vp.PUInt64()
                case "unicast_xmit_packets":
                        counters.UnicastXmitPackets = vp.PUInt64()
+                case "VL15_dropped":
+                        counters.VL15Dropped = vp.PUInt64()
                }
                if err := vp.Err(); err != nil {
diff --git a/vendor/github.com/prometheus/procfs/sysfs/class_power_supply.go b/vendor/github.com/prometheus/procfs/sysfs/class_power_supply.go
index d12e913..dceec9e 100644
--- a/vendor/github.com/prometheus/procfs/sysfs/class_power_supply.go
+++ b/vendor/github.com/prometheus/procfs/sysfs/class_power_supply.go
@@ -110,7 +110,7 @@ func (fs FS) PowerSupplyClass() (PowerSupplyClass, error) {
        dirs, err := ioutil.ReadDir(path)
        if err != nil {
-                return nil, fmt.Errorf("failed to list power supplies at %q: %v", path, err)
+                return nil, err
        }
        psc := make(PowerSupplyClass, len(dirs))
diff --git a/vendor/github.com/prometheus/procfs/sysfs/class_thermal.go b/vendor/github.com/prometheus/procfs/sysfs/class_thermal.go
index cfe11ad..493a531 100644
--- a/vendor/github.com/prometheus/procfs/sysfs/class_thermal.go
+++ b/vendor/github.com/prometheus/procfs/sysfs/class_thermal.go
@@ -16,9 +16,11 @@
 package sysfs
 import (
+        "errors"
        "os"
        "path/filepath"
        "strings"
+        "syscall"
        "github.com/prometheus/procfs/internal/util"
 )
@@ -29,7 +31,7 @@ import (
 type ClassThermalZoneStats struct {
        Name    string  // The name of the zone from the directory structure.
        Type    string  // The type of thermal zone.
-        Temp    uint64  // Temperature in millidegree Celsius.
+        Temp    int64   // Temperature in millidegree Celsius.
        Policy  string  // One of the various thermal governors used for a particular zone.
        Mode    *bool   // Optional: One of the predefined values in [enabled, disabled].
        Passive *uint64 // Optional: millidegrees Celsius. (0 for disabled, > 1000 for enabled+value)
@@ -39,20 +41,20 @@ type ClassThermalZoneStats struct {
 func (fs FS) ClassThermalZoneStats() ([]ClassThermalZoneStats, error) {
        zones, err := filepath.Glob(fs.sys.Path("class/thermal/thermal_zone[0-9]*"))
        if err != nil {
-                return []ClassThermalZoneStats{}, err
+                return nil, err
        }
-        var zoneStats = ClassThermalZoneStats{}
+        stats := make([]ClassThermalZoneStats, 0, len(zones))
-        stats := make([]ClassThermalZoneStats, len(zones))
+        for _, zone := range zones {
-        for i, zone := range zones {
+                zoneStats, err := parseClassThermalZone(zone)
-                zoneName := strings.TrimPrefix(filepath.Base(zone), "thermal_zone")
-                zoneStats, err = parseClassThermalZone(zone)
                if err != nil {
-                        return []ClassThermalZoneStats{}, err
+                        if errors.Is(err, syscall.ENODATA) {
+                                continue
+                        }
+                        return nil, err
                }
-                zoneStats.Name = zoneName
+                zoneStats.Name = strings.TrimPrefix(filepath.Base(zone), "thermal_zone")
-                stats[i] = zoneStats
+                stats = append(stats, zoneStats)
        }
        return stats, nil
 }
@@ -67,7 +69,7 @@ func parseClassThermalZone(zone string) (ClassThermalZoneStats, error) {
        if err != nil {
                return ClassThermalZoneStats{}, err
        }
-        zoneTemp, err := util.ReadUintFromFile(filepath.Join(zone, "temp"))
+        zoneTemp, err := util.ReadIntFromFile(filepath.Join(zone, "temp"))
        if err != nil {
                return ClassThermalZoneStats{}, err
        }
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 05395a0..983f45d 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -81,7 +81,7 @@ github.com/prometheus/common/model
 github.com/prometheus/common/promlog
 github.com/prometheus/common/promlog/flag
 github.com/prometheus/common/version
-# github.com/prometheus/procfs v0.0.11
+# github.com/prometheus/procfs v0.1.3
 ## explicit
 github.com/prometheus/procfs
 github.com/prometheus/procfs/bcache