Add collector for SR-IOV network Virtual Function statistics

Add a new netvf collector that exposes SR-IOV network VF statistics and
configuration via rtnetlink. The collector queries netlink for
interfaces with Virtual Functions and exposes per-VF metrics:

- node_net_vf_info: VF configuration (MAC, VLAN, link state, spoof
  check, trust, PCI address)
- node_net_vf_{receive,transmit}_{packets,bytes}_total: traffic counters
- node_net_vf_{broadcast,multicast}_packets_total: packet type counters
- node_net_vf_{receive,transmit}_dropped_total: drop counters

All metrics include a pci_address label resolved from the sysfs virtfn
symlink, enabling direct correlation with workloads that reference VFs
by PCI BDF address (e.g. OpenStack Nova, libvirt, DPDK).

The collector is disabled by default and can be enabled with
--collector.netvf. PF device filtering is supported via
--collector.netvf.device-include/exclude flags.

Signed-off-by: Anthony Harivel <aharivel@redhat.com>

Author: aharivel

README.md

@@ -106,6 +106,7 @@ hwmon | chip | --collector.hwmon.chip-include | --collector.hwmon.chip-exclude
 hwmon | sensor | --collector.hwmon.sensor-include | --collector.hwmon.sensor-exclude
 interrupts | name | --collector.interrupts.name-include | --collector.interrupts.name-exclude
 netdev | device | --collector.netdev.device-include | --collector.netdev.device-exclude
+netvf | device | --collector.netvf.device-include | --collector.netvf.device-exclude
 qdisk | device | --collector.qdisk.device-include | --collector.qdisk.device-exclude
 slabinfo | slab-names | --collector.slabinfo.slabs-include | --collector.slabinfo.slabs-exclude
 sysctl | all | --collector.sysctl.include | N/A
@@ -202,6 +203,7 @@ logind | Exposes session counts from [logind](http://www.freedesktop.org/wiki/So
 meminfo\_numa | Exposes memory statistics from `/sys/devices/system/node/node[0-9]*/meminfo`, `/sys/devices/system/node/node[0-9]*/numastat`. | Linux
 mountstats | Exposes filesystem statistics from `/proc/self/mountstats`. Exposes detailed NFS client statistics. | Linux
 network_route | Exposes the routing table as metrics | Linux
+netvf | Exposes SR-IOV Virtual Function statistics and configuration from netlink. | Linux
 pcidevice | Exposes pci devices' information including their link status and parent devices. | Linux
 perf | Exposes perf based metrics (Warning: Metrics are dependent on kernel configuration and settings). | Linux
 processes | Exposes aggregate process statistics from `/proc`. | Linux

collector/netvf_linux.go

@@ -0,0 +1,237 @@
+// Copyright The Prometheus Authors
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+//go:build !nonetvf
+
+package collector
+
+import (
+	"errors"
+	"fmt"
+	"log/slog"
+
+	"github.com/alecthomas/kingpin/v2"
+	"github.com/jsimonetti/rtnetlink/v2"
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/procfs/sysfs"
+)
+
+const netvfSubsystem = "net_vf"
+
+var (
+	netvfDeviceInclude = kingpin.Flag("collector.netvf.device-include", "Regexp of PF devices to include (mutually exclusive to device-exclude).").String()
+	netvfDeviceExclude = kingpin.Flag("collector.netvf.device-exclude", "Regexp of PF devices to exclude (mutually exclusive to device-include).").String()
+)
+
+func init() {
+	registerCollector("netvf", defaultDisabled, NewNetVFCollector)
+}
+
+type netvfCollector struct {
+	logger       *slog.Logger
+	deviceFilter deviceFilter
+
+	info            *prometheus.Desc
+	receivePackets  *prometheus.Desc
+	transmitPackets *prometheus.Desc
+	receiveBytes    *prometheus.Desc
+	transmitBytes   *prometheus.Desc
+	broadcast       *prometheus.Desc
+	multicast       *prometheus.Desc
+	receiveDropped  *prometheus.Desc
+	transmitDropped *prometheus.Desc
+}
+
+func NewNetVFCollector(logger *slog.Logger) (Collector, error) {
+	if *netvfDeviceExclude != "" && *netvfDeviceInclude != "" {
+		return nil, errors.New("device-exclude & device-include are mutually exclusive")
+	}
+
+	if *netvfDeviceExclude != "" {
+		logger.Info("Parsed flag --collector.netvf.device-exclude", "flag", *netvfDeviceExclude)
+	}
+
+	if *netvfDeviceInclude != "" {
+		logger.Info("Parsed flag --collector.netvf.device-include", "flag", *netvfDeviceInclude)
+	}
+
+	return &netvfCollector{
+		logger:       logger,
+		deviceFilter: newDeviceFilter(*netvfDeviceExclude, *netvfDeviceInclude),
+		info: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "info"),
+			"Virtual Function configuration information.",
+			[]string{"device", "vf", "mac", "vlan", "link_state", "spoof_check", "trust", "pci_address", "numa_node"}, nil,
+		),
+		receivePackets: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "receive_packets_total"),
+			"Number of received packets by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		transmitPackets: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "transmit_packets_total"),
+			"Number of transmitted packets by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		receiveBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "receive_bytes_total"),
+			"Number of received bytes by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		transmitBytes: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "transmit_bytes_total"),
+			"Number of transmitted bytes by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		broadcast: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "broadcast_packets_total"),
+			"Number of broadcast packets received by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		multicast: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "multicast_packets_total"),
+			"Number of multicast packets received by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		receiveDropped: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "receive_dropped_total"),
+			"Number of dropped received packets by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+		transmitDropped: prometheus.NewDesc(
+			prometheus.BuildFQName(namespace, netvfSubsystem, "transmit_dropped_total"),
+			"Number of dropped transmitted packets by the VF.",
+			[]string{"device", "vf", "pci_address", "numa_node"}, nil,
+		),
+	}, nil
+}
+
+func (c *netvfCollector) Update(ch chan<- prometheus.Metric) error {
+	conn, err := rtnetlink.Dial(nil)
+	if err != nil {
+		return fmt.Errorf("failed to connect to rtnetlink: %w", err)
+	}
+	defer conn.Close()
+
+	links, err := conn.Link.ListWithVFInfo()
+	if err != nil {
+		return fmt.Errorf("failed to list interfaces with VF info: %w", err)
+	}
+
+	vfCount := 0
+	for _, link := range links {
+		if link.Attributes == nil {
+			continue
+		}
+
+		// Skip interfaces without VFs
+		if link.Attributes.NumVF == nil || *link.Attributes.NumVF == 0 {
+			continue
+		}
+
+		device := link.Attributes.Name
+
+		// Apply device filter
+		if c.deviceFilter.ignored(device) {
+			c.logger.Debug("Ignoring device", "device", device)
+			continue
+		}
+
+		numaNode := fmt.Sprintf("%d", pfNumaNode(device))
+
+		for _, vf := range link.Attributes.VFInfoList {
+			vfID := fmt.Sprintf("%d", vf.ID)
+
+			// Emit info metric with VF configuration
+			mac := ""
+			if vf.MAC != nil {
+				mac = vf.MAC.String()
+			}
+			vlan := fmt.Sprintf("%d", vf.Vlan)
+			linkState := vfLinkStateString(vf.LinkState)
+			spoofCheck := fmt.Sprintf("%t", vf.SpoofCheck)
+			trust := fmt.Sprintf("%t", vf.Trust)
+			pciAddress := vfPCIAddress(device, vf.ID)
+
+			ch <- prometheus.MustNewConstMetric(c.info, prometheus.GaugeValue, 1, device, vfID, mac, vlan, linkState, spoofCheck, trust, pciAddress, numaNode)
+
+			// Emit stats metrics if available
+			if vf.Stats == nil {
+				c.logger.Debug("VF has no stats", "device", device, "vf", vf.ID)
+				vfCount++
+				continue
+			}
+
+			stats := vf.Stats
+
+			ch <- prometheus.MustNewConstMetric(c.receivePackets, prometheus.CounterValue, float64(stats.RxPackets), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.transmitPackets, prometheus.CounterValue, float64(stats.TxPackets), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.receiveBytes, prometheus.CounterValue, float64(stats.RxBytes), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.transmitBytes, prometheus.CounterValue, float64(stats.TxBytes), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.broadcast, prometheus.CounterValue, float64(stats.Broadcast), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.multicast, prometheus.CounterValue, float64(stats.Multicast), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.receiveDropped, prometheus.CounterValue, float64(stats.RxDropped), device, vfID, pciAddress, numaNode)
+			ch <- prometheus.MustNewConstMetric(c.transmitDropped, prometheus.CounterValue, float64(stats.TxDropped), device, vfID, pciAddress, numaNode)
+
+			vfCount++
+		}
+	}
+
+	if vfCount == 0 {
+		return ErrNoData
+	}
+
+	return nil
+}
+
+func vfLinkStateString(state rtnetlink.VFLinkState) string {
+	switch state {
+	case rtnetlink.VFLinkStateAuto:
+		return "auto"
+	case rtnetlink.VFLinkStateEnable:
+		return "enable"
+	case rtnetlink.VFLinkStateDisable:
+		return "disable"
+	default:
+		return "unknown"
+	}
+}
+
+// pfNumaNode returns the NUMA node of the PF's PCI device via procfs.
+// Returns -1 (not NUMA-aware) if the value cannot be determined.
+func pfNumaNode(pfDevice string) int {
+	fs, err := sysfs.NewFS(sysFilePath(""))
+	if err != nil {
+		return -1
+	}
+	node, err := fs.NetClassNumaNode(pfDevice)
+	if err != nil {
+		return -1
+	}
+	return node
+}
+
+// vfPCIAddress returns the PCI BDF address of a VF by resolving the sysfs
+// virtfn symlink via procfs. Returns empty string if the address cannot be
+// determined (VF unbound, path missing, etc.).
+func vfPCIAddress(pfDevice string, vfID uint32) string {
+	fs, err := sysfs.NewFS(sysFilePath(""))
+	if err != nil {
+		return ""
+	}
+	addr, err := fs.NetClassVFPCIAddress(pfDevice, vfID)
+	if err != nil {
+		return ""
+	}
+	return addr
+}