Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 .gitignore fixtures/	10 B	2025-05-25 12:27
📄 class_cooling_device.go // 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. //go:build linux // +build linux package sysfs import ( "path/filepath" "strconv" "strings" "github.com/prometheus/procfs/internal/util" ) // ClassCoolingDeviceStats contains info from files in /sys/class/thermal/cooling_device[0-9]* // for a single device. // https://www.kernel.org/doc/Documentation/thermal/sysfs-api.txt type ClassCoolingDeviceStats struct { Name string // The name of the cooling device. Type string // Type of the cooling device(processor/fan/...) MaxState int64 // Maximum cooling state of the cooling device CurState int64 // Current cooling state of the cooling device } func (fs FS) ClassCoolingDeviceStats() ([]ClassCoolingDeviceStats, error) { cds, err := filepath.Glob(fs.sys.Path("class/thermal/cooling_device[0-9]*")) if err != nil { return []ClassCoolingDeviceStats{}, err } var coolingDeviceStats = ClassCoolingDeviceStats{} stats := make([]ClassCoolingDeviceStats, len(cds)) for i, cd := range cds { cdName := strings.TrimPrefix(filepath.Base(cd), "cooling_device") coolingDeviceStats, err = parseCoolingDeviceStats(cd) if err != nil { return []ClassCoolingDeviceStats{}, err } coolingDeviceStats.Name = cdName stats[i] = coolingDeviceStats } return stats, nil } func parseCoolingDeviceStats(cd string) (ClassCoolingDeviceStats, error) { cdType, err := util.SysReadFile(filepath.Join(cd, "type")) if err != nil { return ClassCoolingDeviceStats{}, err } cdMaxStateString, err := util.SysReadFile(filepath.Join(cd, "max_state")) if err != nil { return ClassCoolingDeviceStats{}, err } cdMaxStateInt, err := strconv.ParseInt(cdMaxStateString, 10, 64) if err != nil { return ClassCoolingDeviceStats{}, err } // cur_state can be -1, eg intel powerclamp // https://www.kernel.org/doc/Documentation/thermal/intel_powerclamp.txt cdCurStateString, err := util.SysReadFile(filepath.Join(cd, "cur_state")) if err != nil { return ClassCoolingDeviceStats{}, err } cdCurStateInt, err := strconv.ParseInt(cdCurStateString, 10, 64) if err != nil { return ClassCoolingDeviceStats{}, err } return ClassCoolingDeviceStats{ Type: cdType, MaxState: cdMaxStateInt, CurState: cdCurStateInt, }, nil }	2.73 KB	2025-05-25 12:27
📄 class_cooling_device_test.go // 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. //go:build linux // +build linux package sysfs import ( "reflect" "testing" ) func TestClassCoolingDeviceStats(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } coolingDeviceTest, err := fs.ClassCoolingDeviceStats() if err != nil { t.Fatal(err) } classCoolingDeviceStats := []ClassCoolingDeviceStats{ { Name: "0", Type: "Processor", MaxState: 50, CurState: 0, }, { Name: "1", Type: "intel_powerclamp", MaxState: 27, CurState: -1, }, } if !reflect.DeepEqual(classCoolingDeviceStats, coolingDeviceTest) { t.Errorf("Result not correct: want %v, have %v", classCoolingDeviceStats, coolingDeviceTest) } }	1.27 KB	2025-05-25 12:27
📄 class_dmi.go // Copyright 2021 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 linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "github.com/prometheus/procfs/internal/util" ) const dmiClassPath = "class/dmi/id" // DMIClass contains info from files in /sys/class/dmi/id. type DMIClass struct { BiosDate string // /sys/class/dmi/id/bios_date BiosRelease string // /sys/class/dmi/id/bios_release BiosVendor string // /sys/class/dmi/id/bios_vendor BiosVersion string // /sys/class/dmi/id/bios_version BoardAssetTag string // /sys/class/dmi/id/board_asset_tag BoardName string // /sys/class/dmi/id/board_name BoardSerial string // /sys/class/dmi/id/board_serial BoardVendor string // /sys/class/dmi/id/board_vendor BoardVersion string // /sys/class/dmi/id/board_version ChassisAssetTag string // /sys/class/dmi/id/chassis_asset_tag ChassisSerial string // /sys/class/dmi/id/chassis_serial ChassisType string // /sys/class/dmi/id/chassis_type ChassisVendor string // /sys/class/dmi/id/chassis_vendor ChassisVersion string // /sys/class/dmi/id/chassis_version ProductFamily string // /sys/class/dmi/id/product_family ProductName string // /sys/class/dmi/id/product_name ProductSerial string // /sys/class/dmi/id/product_serial ProductSKU string // /sys/class/dmi/id/product_sku ProductUUID string // /sys/class/dmi/id/product_uuid ProductVersion string // /sys/class/dmi/id/product_version SystemVendor string // /sys/class/dmi/id/sys_vendor } // DMIClass returns Desktop Management Interface (DMI) information read from /sys/class/dmi. func (fs FS) DMIClass() (DMIClass, error) { path := fs.sys.Path(dmiClassPath) files, err := os.ReadDir(path) if err != nil { return nil, fmt.Errorf("failed to read directory %q: %w", path, err) } var dmi DMIClass for _, f := range files { if !f.Type().IsRegular() { continue } name := f.Name() if name == "modalias" \|\| name == "uevent" { continue } filename := filepath.Join(path, name) value, err := util.SysReadFile(filename) if err != nil { if os.IsPermission(err) { // Only root is allowed to read the serial and product_uuid files! continue } return nil, fmt.Errorf("failed to read file %q: %w", filename, err) } switch name { case "bios_date": dmi.BiosDate = &value case "bios_release": dmi.BiosRelease = &value case "bios_vendor": dmi.BiosVendor = &value case "bios_version": dmi.BiosVersion = &value case "board_asset_tag": dmi.BoardAssetTag = &value case "board_name": dmi.BoardName = &value case "board_serial": dmi.BoardSerial = &value case "board_vendor": dmi.BoardVendor = &value case "board_version": dmi.BoardVersion = &value case "chassis_asset_tag": dmi.ChassisAssetTag = &value case "chassis_serial": dmi.ChassisSerial = &value case "chassis_type": dmi.ChassisType = &value case "chassis_vendor": dmi.ChassisVendor = &value case "chassis_version": dmi.ChassisVersion = &value case "product_family": dmi.ProductFamily = &value case "product_name": dmi.ProductName = &value case "product_serial": dmi.ProductSerial = &value case "product_sku": dmi.ProductSKU = &value case "product_uuid": dmi.ProductUUID = &value case "product_version": dmi.ProductVersion = &value case "sys_vendor": dmi.SystemVendor = &value } } return &dmi, nil }	3.92 KB	2025-05-25 12:27
📄 class_dmi_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestDMIClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.DMIClass() if err != nil { t.Fatal(err) } empty := "" biosDate := "04/12/2021" biosRelease := "2.2" biosVendor := "Dell Inc." biosVersion := "2.2.4" boardName := "07PXPY" boardSerial := ".7N62AI2.GRTCL6944100GP." boardVendor := "Dell Inc." boardVersion := "A01" chassisSerial := "7N62AI2" chassisType := "23" chassisVendor := "Dell Inc." productFamily := "PowerEdge" productName := "PowerEdge R6515" productSerial := "7N62AI2" productSKU := "SKU=NotProvided;ModelName=PowerEdge R6515" productUUID := "83340ca8-cb49-4474-8c29-d2088ca84dd9" systemVendor := "Dell Inc." want := &DMIClass{ BiosDate: &biosDate, BiosRelease: &biosRelease, BiosVendor: &biosVendor, BiosVersion: &biosVersion, BoardName: &boardName, BoardSerial: &boardSerial, BoardVendor: &boardVendor, BoardVersion: &boardVersion, ChassisAssetTag: &empty, ChassisSerial: &chassisSerial, ChassisType: &chassisType, ChassisVendor: &chassisVendor, ChassisVersion: &empty, ProductFamily: &productFamily, ProductName: &productName, ProductSerial: &productSerial, ProductSKU: &productSKU, ProductUUID: &productUUID, ProductVersion: &empty, SystemVendor: &systemVendor, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected DMI class (-want +got):\n%s", diff) } }	2.14 KB	2025-05-25 12:27
📄 class_drm.go // Copyright 2021 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 linux // +build linux package sysfs import ( "path/filepath" "github.com/prometheus/procfs/internal/util" ) func readDRMCardField(card, field string) (string, error) { return util.SysReadFile(filepath.Join(card, "device", field)) }	843 B	2025-05-25 12:27
📄 class_drm_amdgpu.go // Copyright 2021 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 linux // +build linux package sysfs import ( "errors" "fmt" "path/filepath" "regexp" "syscall" "github.com/prometheus/procfs/internal/util" ) const ( // Supported device drivers. deviceDriverAMDGPU = "amdgpu" ) // ClassDRMCardAMDGPUStats contains info from files in // /sys/class/drm/card<card>/device for a single amdgpu card. // Not all cards expose all metrics. // https://www.kernel.org/doc/html/latest/gpu/amdgpu.html type ClassDRMCardAMDGPUStats struct { Name string // The card name. GPUBusyPercent uint64 // How busy the GPU is as a percentage. MemoryGTTSize uint64 // The size of the graphics translation table (GTT) block in bytes. MemoryGTTUsed uint64 // The used amount of the graphics translation table (GTT) block in bytes. MemoryVisibleVRAMSize uint64 // The size of visible VRAM in bytes. MemoryVisibleVRAMUsed uint64 // The used amount of visible VRAM in bytes. MemoryVRAMSize uint64 // The size of VRAM in bytes. MemoryVRAMUsed uint64 // The used amount of VRAM in bytes. MemoryVRAMVendor string // The VRAM vendor name. PowerDPMForcePerformanceLevel string // The current power performance level. UniqueID string // The unique ID of the GPU that will persist from machine to machine. } // ClassDRMCardAMDGPUStats returns DRM card metrics for all amdgpu cards. func (fs FS) ClassDRMCardAMDGPUStats() ([]ClassDRMCardAMDGPUStats, error) { cards, err := filepath.Glob(fs.sys.Path("class/drm/card[0-9]")) if err != nil { return nil, err } var stats []ClassDRMCardAMDGPUStats for _, card := range cards { cardStats, err := parseClassDRMAMDGPUCard(card) if err != nil { if errors.Is(err, syscall.ENODATA) { continue } return nil, err } cardStats.Name = filepath.Base(card) stats = append(stats, cardStats) } return stats, nil } func parseClassDRMAMDGPUCard(card string) (ClassDRMCardAMDGPUStats, error) { uevent, err := util.SysReadFile(filepath.Join(card, "device/uevent")) if err != nil { return ClassDRMCardAMDGPUStats{}, err } match, err := regexp.MatchString(fmt.Sprintf("DRIVER=%s", deviceDriverAMDGPU), uevent) if err != nil { return ClassDRMCardAMDGPUStats{}, err } if !match { return ClassDRMCardAMDGPUStats{}, nil } stats := ClassDRMCardAMDGPUStats{Name: card} // Read only specific files for faster data gathering. if v, err := readDRMCardField(card, "gpu_busy_percent"); err == nil { stats.GPUBusyPercent = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_gtt_total"); err == nil { stats.MemoryGTTSize = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_gtt_used"); err == nil { stats.MemoryGTTUsed = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_vis_vram_total"); err == nil { stats.MemoryVisibleVRAMSize = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_vis_vram_used"); err == nil { stats.MemoryVisibleVRAMUsed = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_vram_total"); err == nil { stats.MemoryVRAMSize = util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_vram_used"); err == nil { stats.MemoryVRAMUsed = *util.NewValueParser(v).PUInt64() } if v, err := readDRMCardField(card, "mem_info_vram_vendor"); err == nil { stats.MemoryVRAMVendor = v } if v, err := readDRMCardField(card, "power_dpm_force_performance_level"); err == nil { stats.PowerDPMForcePerformanceLevel = v } if v, err := readDRMCardField(card, "unique_id"); err == nil { stats.UniqueID = v } return stats, nil }	4.28 KB	2025-05-25 12:27
📄 class_drm_amdgpu_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "reflect" "testing" ) func TestClassDRMCardAMDGPUStats(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } drmTest, err := fs.ClassDRMCardAMDGPUStats() if err != nil { t.Fatal(err) } classDRMCardStats := []ClassDRMCardAMDGPUStats{ { Name: "card0", GPUBusyPercent: 4, MemoryGTTSize: 8573157376, MemoryGTTUsed: 144560128, MemoryVisibleVRAMSize: 8573157376, MemoryVisibleVRAMUsed: 1490378752, MemoryVRAMSize: 8573157376, MemoryVRAMUsed: 1490378752, MemoryVRAMVendor: "samsung", PowerDPMForcePerformanceLevel: "manual", UniqueID: "0123456789abcdef", }, } if !reflect.DeepEqual(classDRMCardStats, drmTest) { t.Errorf("Result not correct: want %v, have %v", classDRMCardStats, drmTest) } }	1.54 KB	2025-05-25 12:27
📄 class_fibrechannel.go // 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. //go:build linux // +build linux package sysfs import ( "errors" "fmt" "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 := os.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 { // drivers can choose not to expose some attributes to sysfs. // See: https://github.com/prometheus/node_exporter/issues/2919. if os.IsNotExist(err) { continue } return nil, fmt.Errorf("failed to read file %q: %w", 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 := os.ReadDir(path) if err != nil { return nil, err } for _, f := range files { if !f.Type().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" \|\| errors.Is(err, os.ErrInvalid) { continue } return nil, fmt.Errorf("failed to read file %q: %w", 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 }	8.22 KB	2025-05-25 12:27
📄 class_fibrechannel_test.go // 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. //go:build linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestFibreChannelClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.FibreChannelClass() if err != nil { t.Fatal(err) } // "host0" FibreChannelHost constants. var ( name0 = "host0" speed0 = "16 Gbit" portState0 = "Online" portType0 = "Point-To-Point (direct nport connection)" portName0 = "1000e0071bce95f2" symbolicName0 = "Emulex SN1100E2P FV12.4.270.3 DV12.4.0.0. HN:gotest. OS:Linux" nodeName0 = "2000e0071bce95f2" portID0 = "000002" fabricName0 = "0" devLossTMO0 = "30" supportedClasses0 = "Class 3" supportedSpeeds0 = "4 Gbit, 8 Gbit, 16 Gbit" // "host0" FibreChannelHost.Counters constants. dumpedFrames0 = ^uint64(0) errorFrames0 = uint64(0) invalidCRCCount0 = uint64(0x2) rxFrames0 = uint64(0x3) rxWords0 = uint64(0x4) txFrames0 = uint64(0x5) txWords0 = uint64(0x6) secondsSinceLastReset0 = uint64(0x7) invalidTXWordCount0 = uint64(0x8) linkFailureCount0 = uint64(0x9) lossOfSyncCount0 = uint64(0x10) lossOfSignalCount0 = uint64(0x11) nosCount0 = uint64(0x12) fcpPacketAborts0 = uint64(0x13) ) // "host1" FibreChannelHost constants. var ( name1 = "host1" portState1 = "Online" // "host1" FibreChannelHost.Counters constants. dumpedFrames1 = uint64(0) errorFrames1 = ^uint64(0) invalidCRCCount1 = uint64(0x20) rxFrames1 = uint64(0x30) rxWords1 = uint64(0x40) txFrames1 = uint64(0x50) txWords1 = uint64(0x60) secondsSinceLastReset1 = uint64(0x70) invalidTXWordCount1 = uint64(0x80) linkFailureCount1 = uint64(0x90) lossOfSyncCount1 = uint64(0x100) lossOfSignalCount1 = uint64(0x110) nosCount1 = uint64(0x120) fcpPacketAborts1 = uint64(0x130) ) want := FibreChannelClass{ "host0": FibreChannelHost{ Name: &name0, Speed: &speed0, PortState: &portState0, PortType: &portType0, PortName: &portName0, SymbolicName: &symbolicName0, NodeName: &nodeName0, PortID: &portID0, FabricName: &fabricName0, DevLossTMO: &devLossTMO0, SupportedClasses: &supportedClasses0, SupportedSpeeds: &supportedSpeeds0, Counters: &FibreChannelCounters{ DumpedFrames: &dumpedFrames0, ErrorFrames: &errorFrames0, InvalidCRCCount: &invalidCRCCount0, RXFrames: &rxFrames0, RXWords: &rxWords0, TXFrames: &txFrames0, TXWords: &txWords0, SecondsSinceLastReset: &secondsSinceLastReset0, InvalidTXWordCount: &invalidTXWordCount0, LinkFailureCount: &linkFailureCount0, LossOfSyncCount: &lossOfSyncCount0, LossOfSignalCount: &lossOfSignalCount0, NosCount: &nosCount0, FCPPacketAborts: &fcpPacketAborts0, }, }, "host1": FibreChannelHost{ Name: &name1, PortState: &portState1, Counters: &FibreChannelCounters{ DumpedFrames: &dumpedFrames1, ErrorFrames: &errorFrames1, InvalidCRCCount: &invalidCRCCount1, RXFrames: &rxFrames1, RXWords: &rxWords1, TXFrames: &txFrames1, TXWords: &txWords1, SecondsSinceLastReset: &secondsSinceLastReset1, InvalidTXWordCount: &invalidTXWordCount1, LinkFailureCount: &linkFailureCount1, LossOfSyncCount: &lossOfSyncCount1, LossOfSignalCount: &lossOfSignalCount1, NosCount: &nosCount1, FCPPacketAborts: &fcpPacketAborts1, }, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected FibreChannel class (-want +got):\n%s", diff) } }	4.61 KB	2025-05-25 12:27
📄 class_infiniband.go // 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. //go:build linux // +build linux package sysfs import ( "errors" "fmt" "os" "path/filepath" "strconv" "strings" "github.com/prometheus/procfs/internal/util" ) const infinibandClassPath = "class/infiniband" // InfiniBandCounters contains counter values from files in // /sys/class/infiniband/<Name>/ports/<Port>/counters or // /sys/class/infiniband/<Name>/ports/<Port>/counters_ext // for a single port of one InfiniBand device. type InfiniBandCounters struct { LegacyPortMulticastRcvPackets uint64 // counters_ext/port_multicast_rcv_packets LegacyPortMulticastXmitPackets uint64 // counters_ext/port_multicast_xmit_packets LegacyPortRcvData64 uint64 // counters_ext/port_rcv_data_64 LegacyPortRcvPackets64 uint64 // counters_ext/port_rcv_packets_64 LegacyPortUnicastRcvPackets uint64 // counters_ext/port_unicast_rcv_packets LegacyPortUnicastXmitPackets uint64 // counters_ext/port_unicast_xmit_packets LegacyPortXmitData64 uint64 // counters_ext/port_xmit_data_64 LegacyPortXmitPackets64 uint64 // counters_ext/port_xmit_packets_64 ExcessiveBufferOverrunErrors uint64 // counters/excessive_buffer_overrun_errors LinkDowned uint64 // counters/link_downed LinkErrorRecovery uint64 // counters/link_error_recovery LocalLinkIntegrityErrors uint64 // counters/local_link_integrity_errors MulticastRcvPackets uint64 // counters/multicast_rcv_packets MulticastXmitPackets uint64 // counters/multicast_xmit_packets PortRcvConstraintErrors uint64 // counters/port_rcv_constraint_errors PortRcvData uint64 // counters/port_rcv_data PortRcvDiscards uint64 // counters/port_rcv_discards PortRcvErrors uint64 // counters/port_rcv_errors PortRcvPackets uint64 // counters/port_rcv_packets PortRcvRemotePhysicalErrors uint64 // counters/port_rcv_remote_physical_errors PortRcvSwitchRelayErrors uint64 // counters/port_rcv_switch_relay_errors PortXmitConstraintErrors uint64 // counters/port_xmit_constraint_errors PortXmitData uint64 // counters/port_xmit_data PortXmitDiscards uint64 // counters/port_xmit_discards PortXmitPackets uint64 // counters/port_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 } // InfiniBandHwCounters contains counter value from files in // /sys/class/infiniband/<Name>/ports/<Port>/hw_counters // for a single port of one InfiniBand device. type InfiniBandHwCounters struct { DuplicateRequest uint64 // hw_counters/duplicate_request ImpliedNakSeqErr uint64 // hw_counters/implied_nak_seq_err Lifespan uint64 // hw_counters/lifespan LocalAckTimeoutErr uint64 // hw_counters/local_ack_timeout_err NpCnpSent uint64 // hw_counters/np_cnp_sent NpEcnMarkedRocePackets uint64 // hw_counters/np_ecn_marked_roce_packets OutOfBuffer uint64 // hw_counters/out_of_buffer OutOfSequence uint64 // hw_counters/out_of_sequence PacketSeqErr uint64 // hw_counters/packet_seq_err ReqCqeError uint64 // hw_counters/req_cqe_error ReqCqeFlushError uint64 // hw_counters/req_cqe_flush_error ReqRemoteAccessErrors uint64 // hw_counters/req_remote_access_errors ReqRemoteInvalidRequest uint64 // hw_counters/req_remote_invalid_request RespCqeError uint64 // hw_counters/resp_cqe_error RespCqeFlushError uint64 // hw_counters/resp_cqe_flush_error RespLocalLengthError uint64 // hw_counters/resp_local_length_error RespRemoteAccessErrors uint64 // hw_counters/resp_remote_access_errors RnrNakRetryErr uint64 // hw_counters/rnr_nak_retry_err RoceAdpRetrans uint64 // hw_counters/roce_adp_retrans RoceAdpRetransTo uint64 // hw_counters/roce_adp_retrans_to RoceSlowRestart uint64 // hw_counters/roce_slow_restart RoceSlowRestartCnps uint64 // hw_counters/roce_slow_restart_cnps RoceSlowRestartTrans uint64 // hw_counters/roce_slow_restart_trans RpCnpHandled uint64 // hw_counters/rp_cnp_handled RpCnpIgnored uint64 // hw_counters/rp_cnp_ignored RxAtomicRequests uint64 // hw_counters/rx_atomic_requests RxDctConnect uint64 // hw_counters/rx_dct_connect RxIcrcEncapsulated uint64 // hw_counters/rx_icrc_encapsulated RxReadRequests uint64 // hw_counters/rx_read_requests RxWriteRequests uint64 // hw_counters/rx_write_requests } // InfiniBandPort contains info from files in // /sys/class/infiniband/<Name>/ports/<Port> // for a single port of one InfiniBand device. type InfiniBandPort struct { Name string Port uint State string // String representation from /sys/class/infiniband/<Name>/ports/<Port>/state StateID uint // ID from /sys/class/infiniband/<Name>/ports/<Port>/state PhysState string // String representation from /sys/class/infiniband/<Name>/ports/<Port>/phys_state PhysStateID uint // String representation from /sys/class/infiniband/<Name>/ports/<Port>/phys_state Rate uint64 // in bytes/second from /sys/class/infiniband/<Name>/ports/<Port>/rate Counters InfiniBandCounters HwCounters InfiniBandHwCounters } // InfiniBandDevice contains info from files in /sys/class/infiniband for a // single InfiniBand device. type InfiniBandDevice struct { Name string BoardID string // /sys/class/infiniband/<Name>/board_id FirmwareVersion string // /sys/class/infiniband/<Name>/fw_ver HCAType string // /sys/class/infiniband/<Name>/hca_type Ports map[uint]InfiniBandPort } // InfiniBandClass is a collection of every InfiniBand device in // /sys/class/infiniband. // // The map keys are the names of the InfiniBand devices. type InfiniBandClass map[string]InfiniBandDevice // InfiniBandClass returns info for all InfiniBand devices read from // /sys/class/infiniband. func (fs FS) InfiniBandClass() (InfiniBandClass, error) { path := fs.sys.Path(infinibandClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, err } ibc := make(InfiniBandClass, len(dirs)) for _, d := range dirs { device, err := fs.parseInfiniBandDevice(d.Name()) if err != nil { return nil, err } ibc[device.Name] = device } return ibc, nil } // Parse one InfiniBand device. // Refer to https://www.kernel.org/doc/Documentation/ABI/stable/sysfs-class-infiniband func (fs FS) parseInfiniBandDevice(name string) (InfiniBandDevice, error) { path := fs.sys.Path(infinibandClassPath, name) device := InfiniBandDevice{Name: name} // fw_ver is exposed by all InfiniBand drivers since kernel version 4.10. value, err := util.SysReadFile(filepath.Join(path, "fw_ver")) if err != nil { return nil, fmt.Errorf("failed to read HCA firmware version: %w", err) } device.FirmwareVersion = value // Not all InfiniBand drivers expose all of these. for _, f := range [...]string{"board_id", "hca_type"} { name := filepath.Join(path, f) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } switch f { case "board_id": device.BoardID = value case "hca_type": device.HCAType = value } } portsPath := filepath.Join(path, "ports") ports, err := os.ReadDir(portsPath) if err != nil { return nil, fmt.Errorf("failed to list InfiniBand ports at %q: %w", portsPath, err) } device.Ports = make(map[uint]InfiniBandPort, len(ports)) for _, d := range ports { port, err := fs.parseInfiniBandPort(name, d.Name()) if err != nil { return nil, err } device.Ports[port.Port] = port } return &device, nil } // Parse InfiniBand state. Expected format: "<id>: <string-representation>". func parseState(s string) (uint, string, error) { parts := strings.Split(s, ":") if len(parts) != 2 { return 0, "", fmt.Errorf("failed to split %s into 'ID: NAME'", s) } name := strings.TrimSpace(parts[1]) value, err := strconv.ParseUint(strings.TrimSpace(parts[0]), 10, 32) if err != nil { return 0, name, fmt.Errorf("failed to convert %s into uint", strings.TrimSpace(parts[0])) } id := uint(value) return id, name, nil } // Parse rate (example: "100 Gb/sec (4X EDR)") and return it as bytes/second. func parseRate(s string) (uint64, error) { parts := strings.SplitAfterN(s, " ", 2) if len(parts) != 2 { return 0, fmt.Errorf("failed to split %q", s) } value, err := strconv.ParseFloat(strings.TrimSpace(parts[0]), 32) if err != nil { return 0, fmt.Errorf("failed to convert %s into uint", strings.TrimSpace(parts[0])) } // Convert Gb/s into bytes/s rate := uint64(value 125000000) return rate, nil } // parseInfiniBandPort scans predefined files in /sys/class/infiniband/<device>/ports/<port> // directory and gets their contents. func (fs FS) parseInfiniBandPort(name string, port string) (InfiniBandPort, error) { portNumber, err := strconv.ParseUint(port, 10, 32) if err != nil { return nil, fmt.Errorf("failed to convert %s into uint", port) } ibp := InfiniBandPort{Name: name, Port: uint(portNumber)} portPath := fs.sys.Path(infinibandClassPath, name, "ports", port) content, err := os.ReadFile(filepath.Join(portPath, "state")) if err != nil { return nil, err } id, name, err := parseState(string(content)) if err != nil { return nil, fmt.Errorf("could not parse state file in %q: %w", portPath, err) } ibp.State = name ibp.StateID = id content, err = os.ReadFile(filepath.Join(portPath, "phys_state")) if err != nil { return nil, err } id, name, err = parseState(string(content)) if err != nil { return nil, fmt.Errorf("could not parse phys_state file in %q: %w", portPath, err) } ibp.PhysState = name ibp.PhysStateID = id content, err = os.ReadFile(filepath.Join(portPath, "rate")) if err != nil { return nil, err } ibp.Rate, err = parseRate(string(content)) if err != nil { return nil, fmt.Errorf("could not parse rate file in %q: %w", portPath, err) } // Intel irdma module does not expose /sys/class/infiniband/<device>/ports/<port-num>/counters if !strings.HasPrefix(ibp.Name, "irdma") { counters, err := parseInfiniBandCounters(portPath) if err != nil { return nil, err } ibp.Counters = counters } if strings.HasPrefix(ibp.Name, "irdma") \|\| strings.HasPrefix(ibp.Name, "mlx5_") { hwCounters, err := parseInfiniBandHwCounters(portPath) if err != nil { return nil, err } ibp.HwCounters = hwCounters } return &ibp, nil } // parseInfiniBandCounters parses the counters exposed under // /sys/class/infiniband/<device>/ports/<port-num>/counters, which first appeared in kernel v2.6.12. // Prior to kernel v4.5, 64-bit counters were exposed separately under the "counters_ext" directory. func parseInfiniBandCounters(portPath string) (InfiniBandCounters, error) { var counters InfiniBandCounters path := filepath.Join(portPath, "counters") files, err := os.ReadDir(path) if err != nil { return nil, err } for _, f := range files { if !f.Type().IsRegular() { continue } name := filepath.Join(path, f.Name()) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) \|\| os.IsPermission(err) \|\| err.Error() == "operation not supported" \|\| errors.Is(err, os.ErrInvalid) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } // According to Mellanox, the metrics port_rcv_data, port_xmit_data, // port_rcv_data_64, and port_xmit_data_64 "are divided by 4 unconditionally" // as they represent the amount of data being transmitted and received per lane. // Mellanox cards have 4 lanes per port, so all values must be multiplied by 4 // to get the expected value. vp := util.NewValueParser(value) switch f.Name() { case "excessive_buffer_overrun_errors": counters.ExcessiveBufferOverrunErrors = vp.PUInt64() case "link_downed": counters.LinkDowned = vp.PUInt64() case "link_error_recovery": counters.LinkErrorRecovery = vp.PUInt64() case "local_link_integrity_errors": counters.LocalLinkIntegrityErrors = vp.PUInt64() case "multicast_rcv_packets": counters.MulticastRcvPackets = vp.PUInt64() case "multicast_xmit_packets": counters.MulticastXmitPackets = vp.PUInt64() case "port_rcv_constraint_errors": counters.PortRcvConstraintErrors = vp.PUInt64() case "port_rcv_data": counters.PortRcvData = vp.PUInt64() if counters.PortRcvData != nil { counters.PortRcvData = 4 } case "port_rcv_discards": counters.PortRcvDiscards = vp.PUInt64() case "port_rcv_errors": 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": counters.PortXmitData = vp.PUInt64() if counters.PortXmitData != nil { counters.PortXmitData = 4 } case "port_xmit_discards": counters.PortXmitDiscards = vp.PUInt64() case "port_xmit_packets": 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 { // Ugly workaround for handling https://github.com/prometheus/node_exporter/issues/966 // when counters are `N/A (not available)`. // This was already patched and submitted, see // https://www.spinics.net/lists/linux-rdma/msg68596.html // Remove this as soon as the fix lands in the enterprise distros. if strings.Contains(value, "N/A (no PMA)") { continue } return nil, err } } // Parse pre-kernel-v4.5 64-bit counters. path = filepath.Join(portPath, "counters_ext") files, err = os.ReadDir(path) if err != nil && !os.IsNotExist(err) { return nil, err } for _, f := range files { if !f.Type().IsRegular() { continue } name := filepath.Join(path, f.Name()) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) \|\| os.IsPermission(err) \|\| err.Error() == "operation not supported" \|\| errors.Is(err, os.ErrInvalid) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f.Name() { case "port_multicast_rcv_packets": counters.LegacyPortMulticastRcvPackets = vp.PUInt64() case "port_multicast_xmit_packets": counters.LegacyPortMulticastXmitPackets = vp.PUInt64() case "port_rcv_data_64": counters.LegacyPortRcvData64 = vp.PUInt64() if counters.LegacyPortRcvData64 != nil { counters.LegacyPortRcvData64 = 4 } case "port_rcv_packets_64": counters.LegacyPortRcvPackets64 = vp.PUInt64() case "port_unicast_rcv_packets": counters.LegacyPortUnicastRcvPackets = vp.PUInt64() case "port_unicast_xmit_packets": counters.LegacyPortUnicastXmitPackets = vp.PUInt64() case "port_xmit_data_64": counters.LegacyPortXmitData64 = vp.PUInt64() if counters.LegacyPortXmitData64 != nil { counters.LegacyPortXmitData64 = 4 } case "port_xmit_packets_64": counters.LegacyPortXmitPackets64 = vp.PUInt64() } if err := vp.Err(); err != nil { // Ugly workaround for handling https://github.com/prometheus/node_exporter/issues/966 // when counters are `N/A (not available)`. // This was already patched and submitted, see // https://www.spinics.net/lists/linux-rdma/msg68596.html // Remove this as soon as the fix lands in the enterprise distros. if strings.Contains(value, "N/A (no PMA)") { continue } return nil, err } } return &counters, nil } // parseInfiniBandHwCounters parses the optional counters exposed under // /sys/class/infiniband/<device>/ports/<port-num>/hw_counters, which first appeared in kernel v4.6. func parseInfiniBandHwCounters(portPath string) (*InfiniBandHwCounters, error) { var hwCounters InfiniBandHwCounters path := filepath.Join(portPath, "hw_counters") files, err := os.ReadDir(path) if err != nil { return nil, err } for _, f := range files { if !f.Type().IsRegular() { continue } name := filepath.Join(path, f.Name()) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) \|\| os.IsPermission(err) \|\| err.Error() == "operation not supported" \|\| errors.Is(err, os.ErrInvalid) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f.Name() { case "duplicate_request": hwCounters.DuplicateRequest = vp.PUInt64() case "implied_nak_seq_err": hwCounters.ImpliedNakSeqErr = vp.PUInt64() case "lifespan": hwCounters.Lifespan = vp.PUInt64() case "local_ack_timeout_err": hwCounters.LocalAckTimeoutErr = vp.PUInt64() case "np_cnp_sent": hwCounters.NpCnpSent = vp.PUInt64() case "np_ecn_marked_roce_packets": hwCounters.NpEcnMarkedRocePackets = vp.PUInt64() case "out_of_buffer": hwCounters.OutOfBuffer = vp.PUInt64() case "out_of_sequence": hwCounters.OutOfSequence = vp.PUInt64() case "packet_seq_err": hwCounters.PacketSeqErr = vp.PUInt64() case "req_cqe_error": hwCounters.ReqCqeError = vp.PUInt64() case "req_cqe_flush_error": hwCounters.ReqCqeFlushError = vp.PUInt64() case "req_remote_access_errors": hwCounters.ReqRemoteAccessErrors = vp.PUInt64() case "req_remote_invalid_request": hwCounters.ReqRemoteInvalidRequest = vp.PUInt64() case "resp_cqe_error": hwCounters.RespCqeError = vp.PUInt64() case "resp_cqe_flush_error": hwCounters.RespCqeFlushError = vp.PUInt64() case "resp_local_length_error": hwCounters.RespLocalLengthError = vp.PUInt64() case "resp_remote_access_errors": hwCounters.RespRemoteAccessErrors = vp.PUInt64() case "rnr_nak_retry_err": hwCounters.RnrNakRetryErr = vp.PUInt64() case "roce_adp_retrans": hwCounters.RoceAdpRetrans = vp.PUInt64() case "roce_adp_retrans_to": hwCounters.RoceAdpRetransTo = vp.PUInt64() case "roce_slow_restart": hwCounters.RoceSlowRestart = vp.PUInt64() case "roce_slow_restart_cnps": hwCounters.RoceSlowRestartCnps = vp.PUInt64() case "roce_slow_restart_trans": hwCounters.RoceSlowRestartTrans = vp.PUInt64() case "rp_cnp_handled": hwCounters.RpCnpHandled = vp.PUInt64() case "rp_cnp_ignored": hwCounters.RpCnpIgnored = vp.PUInt64() case "rx_atomic_requests": hwCounters.RxAtomicRequests = vp.PUInt64() case "rx_dct_connect": hwCounters.RxDctConnect = vp.PUInt64() case "rx_icrc_encapsulated": hwCounters.RxIcrcEncapsulated = vp.PUInt64() case "rx_read_requests": hwCounters.RxReadRequests = vp.PUInt64() case "rx_write_requests": hwCounters.RxWriteRequests = vp.PUInt64() } if err := vp.Err(); err != nil { // Ugly workaround for handling https://github.com/prometheus/node_exporter/issues/966 // when counters are `N/A (not available)`. // This was already patched and submitted, see // https://www.spinics.net/lists/linux-rdma/msg68596.html // Remove this as soon as the fix lands in the enterprise distros. if strings.Contains(value, "N/A (no PMA)") { continue } return nil, err } } return &hwCounters, nil }	20.1 KB	2025-05-25 12:27
📄 class_infiniband_test.go // 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. //go:build linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestParseSlowRate(t testing.T) { tests := []struct { rate string want uint64 }{ { rate: "0 GB/sec", want: 0, }, { rate: "2.5 Gb/sec (1X SDR)", want: 312500000, }, { rate: "500 Gb/sec (4X HDR)", want: 62500000000, }, } for _, tt := range tests { rate, err := parseRate(tt.rate) if err != nil { t.Fatal(err) } if rate != tt.want { t.Errorf("Result for InfiniBand rate not correct: want %v, have %v", tt.want, rate) } } } func TestInfiniBandClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.InfiniBandClass() if err != nil { t.Fatal(err) } var ( hfi1Port1ExcessiveBufferOverrunErrors uint64 hfi1Port1LinkDowned uint64 hfi1Port1LinkErrorRecovery uint64 hfi1Port1LocalLinkIntegrityErrors uint64 hfi1Port1PortRcvConstraintErrors uint64 hfi1Port1PortRcvData uint64 = 1380366808104 hfi1Port1PortRcvErrors uint64 hfi1Port1PortRcvPackets uint64 = 638036947 hfi1Port1PortRcvRemotePhysicalErrors uint64 hfi1Port1PortRcvSwitchRelayErrors uint64 hfi1Port1PortXmitConstraintErrors uint64 hfi1Port1PortXmitData uint64 = 1094233306172 hfi1Port1PortXmitDiscards uint64 hfi1Port1PortXmitPackets uint64 = 568318856 hfi1Port1PortXmitWait uint64 hfi1Port1SymbolError uint64 hfi1Port1VL15Dropped uint64 mlx4Port1ExcessiveBufferOverrunErrors uint64 mlx4Port1LinkDowned uint64 mlx4Port1LinkErrorRecovery uint64 mlx4Port1LocalLinkIntegrityErrors uint64 mlx4Port1PortRcvConstraintErrors uint64 mlx4Port1PortRcvData uint64 = 8884894436 mlx4Port1PortRcvErrors uint64 mlx4Port1PortRcvPackets uint64 = 87169372 mlx4Port1PortRcvRemotePhysicalErrors uint64 mlx4Port1PortRcvSwitchRelayErrors uint64 mlx4Port1PortXmitConstraintErrors uint64 mlx4Port1PortXmitData uint64 = 106036453180 mlx4Port1PortXmitDiscards uint64 mlx4Port1PortXmitPackets uint64 = 85734114 mlx4Port1PortXmitWait uint64 = 3599 mlx4Port1SymbolError uint64 mlx4Port1VL15Dropped uint64 mlx4Port2ExcessiveBufferOverrunErrors uint64 mlx4Port2LinkDowned uint64 mlx4Port2LinkErrorRecovery uint64 mlx4Port2LocalLinkIntegrityErrors uint64 mlx4Port2PortRcvConstraintErrors uint64 mlx4Port2PortRcvData uint64 = 9841747136 mlx4Port2PortRcvErrors uint64 mlx4Port2PortRcvPackets uint64 = 89332064 mlx4Port2PortRcvRemotePhysicalErrors uint64 mlx4Port2PortRcvSwitchRelayErrors uint64 mlx4Port2PortXmitConstraintErrors uint64 mlx4Port2PortXmitData uint64 = 106161427560 mlx4Port2PortXmitDiscards uint64 mlx4Port2PortXmitPackets uint64 = 88622850 mlx4Port2PortXmitWait uint64 = 3846 mlx4Port2SymbolError uint64 mlx4Port2VL15Dropped uint64 mlx5Port1ExcessiveBufferOverrunErrors uint64 mlx5Port1LinkDowned uint64 mlx5Port1LinkErrorRecovery uint64 mlx5Port1LocalLinkIntegrityErrors uint64 mlx5Port1MulticastRcvPackets uint64 mlx5Port1MulticastXmitPackets uint64 mlx5Port1PortRcvConstraintErrors uint64 mlx5Port1PortRcvData uint64 = 72505381512 mlx5Port1PortRcvErrors uint64 mlx5Port1PortRcvPackets uint64 = 541889824 mlx5Port1PortRcvRemotePhysicalErrors uint64 mlx5Port1PortRcvSwitchRelayErrors uint64 mlx5Port1PortXmitConstraintErrors uint64 mlx5Port1PortXmitData uint64 = 11523046035392 mlx5Port1PortXmitDiscards uint64 mlx5Port1PortXmitPackets uint64 = 10907922116 mlx5Port1PortXmitWait uint64 mlx5Port1SymbolError uint64 mlx5Port1UnicastRcvPackets uint64 = 541889824 mlx5Port1UnicastXmitPackets uint64 = 10907922116 mlx5Port1VL15Dropped uint64 mlx5Port1DuplicateRequest uint64 = 41 mlx5Port1ImpliedNakSeqErr uint64 mlx5Port1Lifespan uint64 = 10 mlx5Port1LocalAckTimeoutErr uint64 = 131 mlx5Port1OutOfBuffer uint64 mlx5Port1OutOfSequence uint64 = 1 mlx5Port1PacketSeqErr uint64 = 1 mlx5Port1ReqCqeError uint64 = 3481 mlx5Port1ReqCqeFlushError uint64 = 80 mlx5Port1ReqRemoteAccessErrors uint64 mlx5Port1ReqRemoteInvalidRequest uint64 mlx5Port1RespCqeError uint64 = 8109 mlx5Port1RespCqeFlushError uint64 = 4708 mlx5Port1RespLocalLengthError uint64 mlx5Port1RespRemoteAccessErrors uint64 mlx5Port1RnrNakRetryErr uint64 mlx5Port1RoceAdpRetrans uint64 = 99 mlx5Port1RoceAdpRetransTo uint64 = 4 mlx5Port1RoceSlowRestart uint64 mlx5Port1RoceSlowRestartCnps uint64 = 131 mlx5Port1RoceSlowRestartTrans uint64 mlx5Port1RxAtomicRequests uint64 mlx5Port1RxDctConnect uint64 mlx5Port1RxReadRequests uint64 = 175528982 mlx5Port1RxWriteRequests uint64 = 742114 ) want := InfiniBandClass{ "hfi1_0": InfiniBandDevice{ Name: "hfi1_0", BoardID: "HPE 100Gb 1-port OP101 QSFP28 x16 PCIe Gen3 with Intel Omni-Path Adapter", FirmwareVersion: "1.27.0", HCAType: "", Ports: map[uint]InfiniBandPort{ 1: { Name: "hfi1_0", Port: 1, State: "ACTIVE", StateID: 4, PhysState: "LinkUp", PhysStateID: 5, Rate: 12500000000, Counters: InfiniBandCounters{ ExcessiveBufferOverrunErrors: &hfi1Port1ExcessiveBufferOverrunErrors, LinkDowned: &hfi1Port1LinkDowned, LinkErrorRecovery: &hfi1Port1LinkErrorRecovery, LocalLinkIntegrityErrors: &hfi1Port1LocalLinkIntegrityErrors, PortRcvConstraintErrors: &hfi1Port1PortRcvConstraintErrors, PortRcvData: &hfi1Port1PortRcvData, PortRcvErrors: &hfi1Port1PortRcvErrors, PortRcvPackets: &hfi1Port1PortRcvPackets, PortRcvRemotePhysicalErrors: &hfi1Port1PortRcvRemotePhysicalErrors, PortRcvSwitchRelayErrors: &hfi1Port1PortRcvSwitchRelayErrors, PortXmitConstraintErrors: &hfi1Port1PortXmitConstraintErrors, PortXmitData: &hfi1Port1PortXmitData, PortXmitDiscards: &hfi1Port1PortXmitDiscards, PortXmitPackets: &hfi1Port1PortXmitPackets, PortXmitWait: &hfi1Port1PortXmitWait, SymbolError: &hfi1Port1SymbolError, VL15Dropped: &hfi1Port1VL15Dropped, }, }, }, }, "mlx4_0": InfiniBandDevice{ Name: "mlx4_0", BoardID: "SM_1141000001000", FirmwareVersion: "2.31.5050", HCAType: "MT4099", Ports: map[uint]InfiniBandPort{ 1: { Name: "mlx4_0", Port: 1, State: "ACTIVE", StateID: 4, PhysState: "LinkUp", PhysStateID: 5, Rate: 5000000000, Counters: InfiniBandCounters{ ExcessiveBufferOverrunErrors: &mlx4Port1ExcessiveBufferOverrunErrors, LinkDowned: &mlx4Port1LinkDowned, LinkErrorRecovery: &mlx4Port1LinkErrorRecovery, LocalLinkIntegrityErrors: &mlx4Port1LocalLinkIntegrityErrors, PortRcvConstraintErrors: &mlx4Port1PortRcvConstraintErrors, PortRcvData: &mlx4Port1PortRcvData, PortRcvErrors: &mlx4Port1PortRcvErrors, PortRcvPackets: &mlx4Port1PortRcvPackets, PortRcvRemotePhysicalErrors: &mlx4Port1PortRcvRemotePhysicalErrors, PortRcvSwitchRelayErrors: &mlx4Port1PortRcvSwitchRelayErrors, PortXmitConstraintErrors: &mlx4Port1PortXmitConstraintErrors, PortXmitData: &mlx4Port1PortXmitData, PortXmitDiscards: &mlx4Port1PortXmitDiscards, PortXmitPackets: &mlx4Port1PortXmitPackets, PortXmitWait: &mlx4Port1PortXmitWait, SymbolError: &mlx4Port1SymbolError, VL15Dropped: &mlx4Port1VL15Dropped, }, }, 2: { Name: "mlx4_0", Port: 2, State: "ACTIVE", StateID: 4, PhysState: "LinkUp", PhysStateID: 5, Rate: 5000000000, Counters: InfiniBandCounters{ ExcessiveBufferOverrunErrors: &mlx4Port2ExcessiveBufferOverrunErrors, LinkDowned: &mlx4Port2LinkDowned, LinkErrorRecovery: &mlx4Port2LinkErrorRecovery, LocalLinkIntegrityErrors: &mlx4Port2LocalLinkIntegrityErrors, PortRcvConstraintErrors: &mlx4Port2PortRcvConstraintErrors, PortRcvData: &mlx4Port2PortRcvData, PortRcvErrors: &mlx4Port2PortRcvErrors, PortRcvPackets: &mlx4Port2PortRcvPackets, PortRcvRemotePhysicalErrors: &mlx4Port2PortRcvRemotePhysicalErrors, PortRcvSwitchRelayErrors: &mlx4Port2PortRcvSwitchRelayErrors, PortXmitConstraintErrors: &mlx4Port2PortXmitConstraintErrors, PortXmitData: &mlx4Port2PortXmitData, PortXmitDiscards: &mlx4Port2PortXmitDiscards, PortXmitPackets: &mlx4Port2PortXmitPackets, PortXmitWait: &mlx4Port2PortXmitWait, SymbolError: &mlx4Port2SymbolError, VL15Dropped: &mlx4Port2VL15Dropped, }, }, }, }, "mlx5_0": InfiniBandDevice{ Name: "mlx5_0", BoardID: "SM_2001000001034", FirmwareVersion: "14.28.2006", HCAType: "MT4118", Ports: map[uint]InfiniBandPort{ 1: { Name: "mlx5_0", Port: 1, State: "ACTIVE", StateID: 4, PhysState: "ACTIVE", PhysStateID: 4, Rate: 3125000000, Counters: InfiniBandCounters{ ExcessiveBufferOverrunErrors: &mlx5Port1ExcessiveBufferOverrunErrors, LinkDowned: &mlx5Port1LinkDowned, LinkErrorRecovery: &mlx5Port1LinkErrorRecovery, LocalLinkIntegrityErrors: &mlx5Port1LocalLinkIntegrityErrors, MulticastRcvPackets: &mlx5Port1MulticastRcvPackets, MulticastXmitPackets: &mlx5Port1MulticastXmitPackets, PortRcvConstraintErrors: &mlx5Port1PortRcvConstraintErrors, PortRcvData: &mlx5Port1PortRcvData, PortRcvErrors: &mlx5Port1PortRcvErrors, PortRcvPackets: &mlx5Port1PortRcvPackets, PortRcvRemotePhysicalErrors: &mlx5Port1PortRcvRemotePhysicalErrors, PortRcvSwitchRelayErrors: &mlx5Port1PortRcvSwitchRelayErrors, PortXmitConstraintErrors: &mlx5Port1PortXmitConstraintErrors, PortXmitData: &mlx5Port1PortXmitData, PortXmitDiscards: &mlx5Port1PortXmitDiscards, PortXmitPackets: &mlx5Port1PortXmitPackets, PortXmitWait: &mlx5Port1PortXmitWait, SymbolError: &mlx5Port1SymbolError, UnicastRcvPackets: &mlx5Port1UnicastRcvPackets, UnicastXmitPackets: &mlx5Port1UnicastXmitPackets, VL15Dropped: &mlx5Port1VL15Dropped, }, HwCounters: InfiniBandHwCounters{ DuplicateRequest: &mlx5Port1DuplicateRequest, ImpliedNakSeqErr: &mlx5Port1ImpliedNakSeqErr, Lifespan: &mlx5Port1Lifespan, LocalAckTimeoutErr: &mlx5Port1LocalAckTimeoutErr, OutOfBuffer: &mlx5Port1OutOfBuffer, OutOfSequence: &mlx5Port1OutOfSequence, PacketSeqErr: &mlx5Port1PacketSeqErr, ReqCqeError: &mlx5Port1ReqCqeError, ReqCqeFlushError: &mlx5Port1ReqCqeFlushError, ReqRemoteAccessErrors: &mlx5Port1ReqRemoteAccessErrors, ReqRemoteInvalidRequest: &mlx5Port1ReqRemoteInvalidRequest, RespCqeError: &mlx5Port1RespCqeError, RespCqeFlushError: &mlx5Port1RespCqeFlushError, RespLocalLengthError: &mlx5Port1RespLocalLengthError, RespRemoteAccessErrors: &mlx5Port1RespRemoteAccessErrors, RnrNakRetryErr: &mlx5Port1RnrNakRetryErr, RoceAdpRetrans: &mlx5Port1RoceAdpRetrans, RoceAdpRetransTo: &mlx5Port1RoceAdpRetransTo, RoceSlowRestart: &mlx5Port1RoceSlowRestart, RoceSlowRestartCnps: &mlx5Port1RoceSlowRestartCnps, RoceSlowRestartTrans: &mlx5Port1RoceSlowRestartTrans, RxAtomicRequests: &mlx5Port1RxAtomicRequests, RxDctConnect: &mlx5Port1RxDctConnect, RxReadRequests: &mlx5Port1RxReadRequests, RxWriteRequests: &mlx5Port1RxWriteRequests, }, }, }, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected InfiniBand class (-want +got):\n%s", diff) } }	13.92 KB	2025-05-25 12:27
📄 class_nvme.go // Copyright 2021 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 linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "github.com/prometheus/procfs/internal/util" ) const nvmeClassPath = "class/nvme" // NVMeDevice contains info from files in /sys/class/nvme for a single NVMe device. type NVMeDevice struct { Name string Serial string // /sys/class/nvme/<Name>/serial Model string // /sys/class/nvme/<Name>/model State string // /sys/class/nvme/<Name>/state FirmwareRevision string // /sys/class/nvme/<Name>/firmware_rev } // NVMeClass is a collection of every NVMe device in /sys/class/nvme. // // The map keys are the names of the NVMe devices. type NVMeClass map[string]NVMeDevice // NVMeClass returns info for all NVMe devices read from /sys/class/nvme. func (fs FS) NVMeClass() (NVMeClass, error) { path := fs.sys.Path(nvmeClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, fmt.Errorf("failed to list NVMe devices at %q: %w", path, err) } nc := make(NVMeClass, len(dirs)) for _, d := range dirs { device, err := fs.parseNVMeDevice(d.Name()) if err != nil { return nil, err } nc[device.Name] = device } return nc, nil } // Parse one NVMe device. func (fs FS) parseNVMeDevice(name string) (NVMeDevice, error) { path := fs.sys.Path(nvmeClassPath, name) device := NVMeDevice{Name: name} for _, f := range [...]string{"firmware_rev", "model", "serial", "state"} { name := filepath.Join(path, f) value, err := util.SysReadFile(name) if err != nil { return nil, fmt.Errorf("failed to read file %q: %w", name, err) } switch f { case "firmware_rev": device.FirmwareRevision = value case "model": device.Model = value case "serial": device.Serial = value case "state": device.State = value } } return &device, nil }	2.36 KB	2025-05-25 12:27
📄 class_nvme_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestNVMeClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.NVMeClass() if err != nil { t.Fatal(err) } want := NVMeClass{ "nvme0": NVMeDevice{ Name: "nvme0", FirmwareRevision: "1B2QEXP7", Model: "Samsung SSD 970 PRO 512GB", Serial: "S680HF8N190894I", State: "live", }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected NVMe class (-want +got):\n%s", diff) } }	1.18 KB	2025-05-25 12:27
📄 class_power_supply.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "errors" "fmt" "os" "path/filepath" "github.com/prometheus/procfs/internal/util" ) // PowerSupply contains info from files in /sys/class/power_supply for a // single power supply. type PowerSupply struct { Name string // Power Supply Name Authentic int64 // /sys/class/power_supply/<Name>/authentic Calibrate int64 // /sys/class/power_supply/<Name>/calibrate Capacity int64 // /sys/class/power_supply/<Name>/capacity CapacityAlertMax int64 // /sys/class/power_supply/<Name>/capacity_alert_max CapacityAlertMin int64 // /sys/class/power_supply/<Name>/capacity_alert_min CapacityLevel string // /sys/class/power_supply/<Name>/capacity_level ChargeAvg int64 // /sys/class/power_supply/<Name>/charge_avg ChargeControlLimit int64 // /sys/class/power_supply/<Name>/charge_control_limit ChargeControlLimitMax int64 // /sys/class/power_supply/<Name>/charge_control_limit_max ChargeCounter int64 // /sys/class/power_supply/<Name>/charge_counter ChargeEmpty int64 // /sys/class/power_supply/<Name>/charge_empty ChargeEmptyDesign int64 // /sys/class/power_supply/<Name>/charge_empty_design ChargeFull int64 // /sys/class/power_supply/<Name>/charge_full ChargeFullDesign int64 // /sys/class/power_supply/<Name>/charge_full_design ChargeNow int64 // /sys/class/power_supply/<Name>/charge_now ChargeTermCurrent int64 // /sys/class/power_supply/<Name>/charge_term_current ChargeType string // /sys/class/power_supply/<Name>/charge_type ConstantChargeCurrent int64 // /sys/class/power_supply/<Name>/constant_charge_current ConstantChargeCurrentMax int64 // /sys/class/power_supply/<Name>/constant_charge_current_max ConstantChargeVoltage int64 // /sys/class/power_supply/<Name>/constant_charge_voltage ConstantChargeVoltageMax int64 // /sys/class/power_supply/<Name>/constant_charge_voltage_max CurrentAvg int64 // /sys/class/power_supply/<Name>/current_avg CurrentBoot int64 // /sys/class/power_supply/<Name>/current_boot CurrentMax int64 // /sys/class/power_supply/<Name>/current_max CurrentNow int64 // /sys/class/power_supply/<Name>/current_now CycleCount int64 // /sys/class/power_supply/<Name>/cycle_count EnergyAvg int64 // /sys/class/power_supply/<Name>/energy_avg EnergyEmpty int64 // /sys/class/power_supply/<Name>/energy_empty EnergyEmptyDesign int64 // /sys/class/power_supply/<Name>/energy_empty_design EnergyFull int64 // /sys/class/power_supply/<Name>/energy_full EnergyFullDesign int64 // /sys/class/power_supply/<Name>/energy_full_design EnergyNow int64 // /sys/class/power_supply/<Name>/energy_now Health string // /sys/class/power_supply/<Name>/health InputCurrentLimit int64 // /sys/class/power_supply/<Name>/input_current_limit Manufacturer string // /sys/class/power_supply/<Name>/manufacturer ModelName string // /sys/class/power_supply/<Name>/model_name Online int64 // /sys/class/power_supply/<Name>/online PowerAvg int64 // /sys/class/power_supply/<Name>/power_avg PowerNow int64 // /sys/class/power_supply/<Name>/power_now PrechargeCurrent int64 // /sys/class/power_supply/<Name>/precharge_current Present int64 // /sys/class/power_supply/<Name>/present Scope string // /sys/class/power_supply/<Name>/scope SerialNumber string // /sys/class/power_supply/<Name>/serial_number Status string // /sys/class/power_supply/<Name>/status Technology string // /sys/class/power_supply/<Name>/technology Temp int64 // /sys/class/power_supply/<Name>/temp TempAlertMax int64 // /sys/class/power_supply/<Name>/temp_alert_max TempAlertMin int64 // /sys/class/power_supply/<Name>/temp_alert_min TempAmbient int64 // /sys/class/power_supply/<Name>/temp_ambient TempAmbientMax int64 // /sys/class/power_supply/<Name>/temp_ambient_max TempAmbientMin int64 // /sys/class/power_supply/<Name>/temp_ambient_min TempMax int64 // /sys/class/power_supply/<Name>/temp_max TempMin int64 // /sys/class/power_supply/<Name>/temp_min TimeToEmptyAvg int64 // /sys/class/power_supply/<Name>/time_to_empty_avg TimeToEmptyNow int64 // /sys/class/power_supply/<Name>/time_to_empty_now TimeToFullAvg int64 // /sys/class/power_supply/<Name>/time_to_full_avg TimeToFullNow int64 // /sys/class/power_supply/<Name>/time_to_full_now Type string // /sys/class/power_supply/<Name>/type UsbType string // /sys/class/power_supply/<Name>/usb_type VoltageAvg int64 // /sys/class/power_supply/<Name>/voltage_avg VoltageBoot int64 // /sys/class/power_supply/<Name>/voltage_boot VoltageMax int64 // /sys/class/power_supply/<Name>/voltage_max VoltageMaxDesign int64 // /sys/class/power_supply/<Name>/voltage_max_design VoltageMin int64 // /sys/class/power_supply/<Name>/voltage_min VoltageMinDesign int64 // /sys/class/power_supply/<Name>/voltage_min_design VoltageNow int64 // /sys/class/power_supply/<Name>/voltage_now VoltageOCV int64 // /sys/class/power_supply/<Name>/voltage_ocv } // PowerSupplyClass is a collection of every power supply in // /sys/class/power_supply. // // The map keys are the names of the power supplies. type PowerSupplyClass map[string]PowerSupply // PowerSupplyClass returns info for all power supplies read from // /sys/class/power_supply. func (fs FS) PowerSupplyClass() (PowerSupplyClass, error) { path := fs.sys.Path("class/power_supply") dirs, err := os.ReadDir(path) if err != nil { return nil, err } psc := make(PowerSupplyClass, len(dirs)) for _, d := range dirs { ps, err := parsePowerSupply(filepath.Join(path, d.Name())) if err != nil { return nil, err } ps.Name = d.Name() psc[d.Name()] = ps } return psc, nil } func parsePowerSupply(path string) (PowerSupply, error) { files, err := os.ReadDir(path) if err != nil { return nil, err } var ps PowerSupply for _, f := range files { if !f.Type().IsRegular() { continue } name := filepath.Join(path, f.Name()) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) \|\| err.Error() == "operation not supported" \|\| err.Error() == "no such device" \|\| errors.Is(err, os.ErrInvalid) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f.Name() { case "authentic": ps.Authentic = vp.PInt64() case "calibrate": ps.Calibrate = vp.PInt64() case "capacity": ps.Capacity = vp.PInt64() case "capacity_alert_max": ps.CapacityAlertMax = vp.PInt64() case "capacity_alert_min": ps.CapacityAlertMin = vp.PInt64() case "capacity_level": ps.CapacityLevel = value case "charge_avg": ps.ChargeAvg = vp.PInt64() case "charge_control_limit": ps.ChargeControlLimit = vp.PInt64() case "charge_control_limit_max": ps.ChargeControlLimitMax = vp.PInt64() case "charge_counter": ps.ChargeCounter = vp.PInt64() case "charge_empty": ps.ChargeEmpty = vp.PInt64() case "charge_empty_design": ps.ChargeEmptyDesign = vp.PInt64() case "charge_full": ps.ChargeFull = vp.PInt64() case "charge_full_design": ps.ChargeFullDesign = vp.PInt64() case "charge_now": ps.ChargeNow = vp.PInt64() case "charge_term_current": ps.ChargeTermCurrent = vp.PInt64() case "charge_type": ps.ChargeType = value case "constant_charge_current": ps.ConstantChargeCurrent = vp.PInt64() case "constant_charge_current_max": ps.ConstantChargeCurrentMax = vp.PInt64() case "constant_charge_voltage": ps.ConstantChargeVoltage = vp.PInt64() case "constant_charge_voltage_max": ps.ConstantChargeVoltageMax = vp.PInt64() case "current_avg": ps.CurrentAvg = vp.PInt64() case "current_boot": ps.CurrentBoot = vp.PInt64() case "current_max": ps.CurrentMax = vp.PInt64() case "current_now": ps.CurrentNow = vp.PInt64() case "cycle_count": ps.CycleCount = vp.PInt64() case "energy_avg": ps.EnergyAvg = vp.PInt64() case "energy_empty": ps.EnergyEmpty = vp.PInt64() case "energy_empty_design": ps.EnergyEmptyDesign = vp.PInt64() case "energy_full": ps.EnergyFull = vp.PInt64() case "energy_full_design": ps.EnergyFullDesign = vp.PInt64() case "energy_now": ps.EnergyNow = vp.PInt64() case "health": ps.Health = value case "input_current_limit": ps.InputCurrentLimit = vp.PInt64() case "manufacturer": ps.Manufacturer = value case "model_name": ps.ModelName = value case "online": ps.Online = vp.PInt64() case "power_avg": ps.PowerAvg = vp.PInt64() case "power_now": ps.PowerNow = vp.PInt64() case "precharge_current": ps.PrechargeCurrent = vp.PInt64() case "present": ps.Present = vp.PInt64() case "scope": ps.Scope = value case "serial_number": ps.SerialNumber = value case "status": ps.Status = value case "technology": ps.Technology = value case "temp": ps.Temp = vp.PInt64() case "temp_alert_max": ps.TempAlertMax = vp.PInt64() case "temp_alert_min": ps.TempAlertMin = vp.PInt64() case "temp_ambient": ps.TempAmbient = vp.PInt64() case "temp_ambient_max": ps.TempAmbientMax = vp.PInt64() case "temp_ambient_min": ps.TempAmbientMin = vp.PInt64() case "temp_max": ps.TempMax = vp.PInt64() case "temp_min": ps.TempMin = vp.PInt64() case "time_to_empty_avg": ps.TimeToEmptyAvg = vp.PInt64() case "time_to_empty_now": ps.TimeToEmptyNow = vp.PInt64() case "time_to_full_avg": ps.TimeToFullAvg = vp.PInt64() case "time_to_full_now": ps.TimeToFullNow = vp.PInt64() case "type": ps.Type = value case "usb_type": ps.UsbType = value case "voltage_avg": ps.VoltageAvg = vp.PInt64() case "voltage_boot": ps.VoltageBoot = vp.PInt64() case "voltage_max": ps.VoltageMax = vp.PInt64() case "voltage_max_design": ps.VoltageMaxDesign = vp.PInt64() case "voltage_min": ps.VoltageMin = vp.PInt64() case "voltage_min_design": ps.VoltageMinDesign = vp.PInt64() case "voltage_now": ps.VoltageNow = vp.PInt64() case "voltage_ocv": ps.VoltageOCV = vp.PInt64() } if err := vp.Err(); err != nil { return nil, err } } return &ps, nil }	11.23 KB	2025-05-25 12:27
📄 class_power_supply_test.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestPowerSupplyClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatalf("failed to open filesystem: %v", err) } got, err := fs.PowerSupplyClass() if err != nil { t.Fatalf("failed to parse power supply class: %v", err) } var ( acOnline int64 bat0Capacity int64 = 98 bat0CycleCount int64 bat0EnergyFull int64 = 50060000 bat0EnergyFullDesign int64 = 47520000 bat0EnergyNow int64 = 49450000 bat0PowerNow int64 = 4830000 bat0Present int64 = 1 bat0VoltageMinDesign int64 = 10800000 bat0VoltageNow int64 = 12229000 ) want := PowerSupplyClass{ "AC": { Name: "AC", Type: "Mains", Online: &acOnline, }, "BAT0": { Name: "BAT0", Capacity: &bat0Capacity, CapacityLevel: "Normal", CycleCount: &bat0CycleCount, EnergyFull: &bat0EnergyFull, EnergyFullDesign: &bat0EnergyFullDesign, EnergyNow: &bat0EnergyNow, Manufacturer: "LGC", ModelName: "LNV-45N1", PowerNow: &bat0PowerNow, Present: &bat0Present, SerialNumber: "38109", Status: "Discharging", Technology: "Li-ion", Type: "Battery", VoltageMinDesign: &bat0VoltageMinDesign, VoltageNow: &bat0VoltageNow, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected power supply class (-want +got):\n%s", diff) } }	2.12 KB	2025-05-25 12:27
📄 class_powercap.go // 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. //go:build linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "strconv" "strings" "github.com/prometheus/procfs/internal/util" ) // RaplZone stores the information for one RAPL power zone. type RaplZone struct { Name string // name of RAPL zone from file "name" Index int // index (different value for duplicate names) Path string // filesystem path of RaplZone MaxMicrojoules uint64 // max RAPL microjoule value } // GetRaplZones returns a slice of RaplZones. When RAPL files are not present, // returns nil with error. // - https://www.kernel.org/doc/Documentation/power/powercap/powercap.txt func GetRaplZones(fs FS) ([]RaplZone, error) { raplDir := fs.sys.Path("class/powercap") files, err := os.ReadDir(raplDir) if err != nil { return nil, fmt.Errorf("unable to read class/powercap: %w", err) } var zones []RaplZone // Count name usages to avoid duplicates (label them with an index). countNameUsages := make(map[string]int) // Loop through directory files searching for file "name" from subdirs. for _, f := range files { nameFile := filepath.Join(raplDir, f.Name(), "/name") nameBytes, err := os.ReadFile(nameFile) if err == nil { // Add new rapl zone since name file was found. name := strings.TrimSpace(string(nameBytes)) // get a pair of index and final name index, name := getIndexAndName(countNameUsages, name) maxMicrojouleFilename := filepath.Join(raplDir, f.Name(), "/max_energy_range_uj") maxMicrojoules, err := util.ReadUintFromFile(maxMicrojouleFilename) if err != nil { return nil, err } zone := RaplZone{ Name: name, Index: index, Path: filepath.Join(raplDir, f.Name()), MaxMicrojoules: maxMicrojoules, } zones = append(zones, zone) // Store into map how many times this name has been used. There can // be e.g. multiple "dram" instances without any index postfix. The // count is then used for indexing countNameUsages[name] = index + 1 } } return zones, nil } // GetEnergyMicrojoules returns the current microjoule value from the zone energy counter // https://www.kernel.org/doc/Documentation/power/powercap/powercap.txt func (rz RaplZone) GetEnergyMicrojoules() (uint64, error) { return util.ReadUintFromFile(filepath.Join(rz.Path, "/energy_uj")) } // getIndexAndName returns a pair of (index, name) for a given name and name // counting map. Some RAPL-names have an index at the end, some have duplicates // without an index at the end. When the index is embedded in the name, it is // provided back as an integer, and stripped from the returned name. Usage // count is used when the index value is absent from the name. func getIndexAndName(countNameUsages map[string]int, name string) (int, string) { s := strings.Split(name, "-") if len(s) == 2 { index, err := strconv.Atoi(s[1]) if err == nil { return index, s[0] } } // return count as the index, since name didn't have an index at the end return countNameUsages[name], name }	3.58 KB	2025-05-25 12:27
📄 class_powercap_test.go // 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. //go:build linux // +build linux package sysfs import ( "path/filepath" "testing" ) func TestGetRaplZones(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } zones, err := GetRaplZones(fs) if err != nil \|\| zones == nil { t.Fatal(err) } } func TestNoRaplFiles(t testing.T) { // use a bad (but existing) fs path fs, err := NewFS(filepath.Join(sysTestFixtures, "class")) if err != nil { t.Fatal(err) } zones, err := GetRaplZones(fs) // expect failure if err == nil \|\| zones != nil { t.Fatal(err) } } func TestNewRaplValues(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } zones, err := GetRaplZones(fs) if err != nil \|\| zones == nil { t.Fatal(err) } if len(zones) != 3 { t.Fatal("wrong number of RAPL values") } microjoules, err := zones[0].GetEnergyMicrojoules() if err != nil { t.Fatal("couldn't read microjoules") } if microjoules != 240422366267 { t.Fatal("wrong microjoule number") } if zones[2].Index != 10 { t.Fatal("wrong index number") } }	1.62 KB	2025-05-25 12:27
📄 class_sas_device.go // Copyright 2022 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 linux // +build linux package sysfs import ( "os" "path/filepath" "regexp" "github.com/prometheus/procfs/internal/util" ) const ( sasDeviceClassPath = "class/sas_device" sasEndDeviceClassPath = "class/sas_end_device" sasExpanderClassPath = "class/sas_expander" ) type SASDevice struct { Name string // /sys/class/sas_device/<Name> SASAddress string // /sys/class/sas_device/<Name>/sas_address SASPhys []string // /sys/class/sas_device/<Name>/device/phy-* SASPorts []string // /sys/class/sas_device/<Name>/device/ports-* BlockDevices []string // /sys/class/sas_device/<Name>/device/target//block/* } type SASDeviceClass map[string]SASDevice var ( sasTargetDeviceRegexp = regexp.MustCompile(`^target[0-9:]+$`) sasTargetSubDeviceRegexp = regexp.MustCompile(`[0-9]+:.`) ) // sasDeviceClasses reads all of the SAS devices from a specific set // of /sys/class/sas/ entries. The sas_device, sas_end_device, and // sas_expander classes are all nearly identical and can be handled by the same basic code. func (fs FS) parseSASDeviceClass(dir string) (SASDeviceClass, error) { path := fs.sys.Path(dir) dirs, err := os.ReadDir(path) if err != nil { return nil, err } sdc := make(SASDeviceClass, len(dirs)) for _, d := range dirs { device, err := fs.parseSASDevice(d.Name()) if err != nil { return nil, err } sdc[device.Name] = device } return sdc, nil } // SASDeviceClass parses devices in /sys/class/sas_device. func (fs FS) SASDeviceClass() (SASDeviceClass, error) { return fs.parseSASDeviceClass(sasDeviceClassPath) } // SASEndDeviceClass parses devices in /sys/class/sas_end_device. // This is a subset of sas_device, and excludes expanders. func (fs FS) SASEndDeviceClass() (SASDeviceClass, error) { return fs.parseSASDeviceClass(sasEndDeviceClassPath) } // SASExpanderClass parses devices in /sys/class/sas_expander. // This is a subset of sas_device, but only includes expanders. func (fs FS) SASExpanderClass() (SASDeviceClass, error) { return fs.parseSASDeviceClass(sasExpanderClassPath) } // Parse a single sas_device. This uses /sys/class/sas_device, as // it's a superset of the other two directories so there's no reason // to plumb the path through to here. func (fs FS) parseSASDevice(name string) (SASDevice, error) { device := SASDevice{Name: name} devicepath := fs.sys.Path(filepath.Join(sasDeviceClassPath, name, "device")) dirs, err := os.ReadDir(devicepath) if err != nil { return nil, err } for _, d := range dirs { if sasPhyDeviceRegexp.MatchString(d.Name()) { device.SASPhys = append(device.SASPhys, d.Name()) } if sasPortDeviceRegexp.MatchString(d.Name()) { device.SASPorts = append(device.SASPorts, d.Name()) } } address := fs.sys.Path(sasDeviceClassPath, name, "sas_address") value, err := util.SysReadFile(address) if err != nil { return nil, err } device.SASAddress = value device.BlockDevices, err = fs.blockSASDeviceBlockDevices(name) if err != nil { return nil, err } return &device, nil } // Identify block devices that map to a specific SAS Device // This info comes from (for example) // /sys/class/sas_device/end_device-11:2/device/target11:0:0/11:0:0:0/block/sdp // // To find that, we have to look in the device directory for target$X // subdirs, then specific subdirs of $X, then read from directory // names in the 'block/' subdirectory under that. This really // shouldn't be this hard. func (fs FS) blockSASDeviceBlockDevices(name string) ([]string, error) { var devices []string devicepath := fs.sys.Path(filepath.Join(sasDeviceClassPath, name, "device")) dirs, err := os.ReadDir(devicepath) if err != nil { return nil, err } for _, d := range dirs { if sasTargetDeviceRegexp.MatchString(d.Name()) { targetdir := d.Name() subtargets, err := os.ReadDir(filepath.Join(devicepath, targetdir)) if err != nil { return nil, err } for _, targetsubdir := range subtargets { if !sasTargetSubDeviceRegexp.MatchString(targetsubdir.Name()) { // need to skip 'power', 'subsys', etc. continue } blocks, err := os.ReadDir(filepath.Join(devicepath, targetdir, targetsubdir.Name(), "block")) if err != nil { if os.IsNotExist(err) { continue } return nil, err } for _, blockdevice := range blocks { devices = append(devices, blockdevice.Name()) } } } } return devices, nil } // GetByName returns the SASDevice with the provided name. func (sdc SASDeviceClass) GetByName(name string) SASDevice { return (sdc)[name] } // GetByPhy finds the SASDevice that contains the provided PHY name. func (sdc SASDeviceClass) GetByPhy(name string) SASDevice { for _, d := range sdc { for _, p := range d.SASPhys { if p == name { return d } } } return nil } // GetByPort finds the SASDevice that contains the provided SAS Port name. func (sdc SASDeviceClass) GetByPort(name string) SASDevice { for _, d := range *sdc { for _, p := range d.SASPorts { if p == name { return d } } } return nil }	5.55 KB	2025-05-25 12:27
📄 class_sas_device_test.go // Copyright 2022 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestSASDeviceClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASDeviceClass() if err != nil { t.Fatal(err) } want := SASDeviceClass{ "end_device-11:0:0": { Name: "end_device-11:0:0", SASAddress: "0x5000ccab02009402", BlockDevices: []string{"sdv"}, }, "end_device-11:0:1": { Name: "end_device-11:0:1", SASAddress: "0x5000cca26128b1f5", BlockDevices: []string{"sdw"}, }, "end_device-11:0:2": { Name: "end_device-11:0:2", SASAddress: "0x5000ccab02009406", BlockDevices: []string{"sdx"}, }, "end_device-11:2": { Name: "end_device-11:2", SASAddress: "0x5000cca0506b5f1d", BlockDevices: []string{"sdp"}, }, "expander-11:0": { Name: "expander-11:0", SASAddress: "0x5000ccab0200947e", SASPhys: []string{ "phy-11:0:10", "phy-11:0:11", "phy-11:0:12", "phy-11:0:13", "phy-11:0:14", "phy-11:0:15", "phy-11:0:2", "phy-11:0:4", "phy-11:0:6", "phy-11:0:7", "phy-11:0:8", "phy-11:0:9", }, SASPorts: []string{ "port-11:0:0", "port-11:0:1", "port-11:0:2", }, }, "expander-11:1": { Name: "expander-11:1", SASAddress: "0x5003048001e8967f", }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } } func TestSASEndDeviceClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASEndDeviceClass() if err != nil { t.Fatal(err) } want := SASDeviceClass{ "end_device-11:0:0": { Name: "end_device-11:0:0", SASAddress: "0x5000ccab02009402", BlockDevices: []string{"sdv"}, }, "end_device-11:0:1": { Name: "end_device-11:0:1", SASAddress: "0x5000cca26128b1f5", BlockDevices: []string{"sdw"}, }, "end_device-11:0:2": { Name: "end_device-11:0:2", SASAddress: "0x5000ccab02009406", BlockDevices: []string{"sdx"}, }, "end_device-11:2": { Name: "end_device-11:2", SASAddress: "0x5000cca0506b5f1d", BlockDevices: []string{"sdp"}, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } } func TestSASExpanderClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASExpanderClass() if err != nil { t.Fatal(err) } want := SASDeviceClass{ "expander-11:0": { Name: "expander-11:0", SASAddress: "0x5000ccab0200947e", SASPhys: []string{ "phy-11:0:10", "phy-11:0:11", "phy-11:0:12", "phy-11:0:13", "phy-11:0:14", "phy-11:0:15", "phy-11:0:2", "phy-11:0:4", "phy-11:0:6", "phy-11:0:7", "phy-11:0:8", "phy-11:0:9", }, SASPorts: []string{ "port-11:0:0", "port-11:0:1", "port-11:0:2", }, }, "expander-11:1": { Name: "expander-11:1", SASAddress: "0x5003048001e8967f", }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } } func TestSASDeviceGetByName(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASDeviceClass() if err != nil { t.Fatal(err) } want := "expander-11:0" got := dc.GetByName("expander-11:0").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice name (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByName("expander-15") if got2 != nil { t.Fatalf("unexpected GetByName response: got %v want nil", got2) } } func TestSASDeviceGetByPhy(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASDeviceClass() if err != nil { t.Fatal(err) } want := "expander-11:0" got := dc.GetByPhy("phy-11:0:11").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByPhy("phy-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } } func TestSASDeviceGetByPort(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASDeviceClass() if err != nil { t.Fatal(err) } want := "expander-11:0" got := dc.GetByPort("port-11:0:0").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByPort("port-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } }	5.18 KB	2025-05-25 12:27
📄 class_sas_host.go // Copyright 2021 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 linux // +build linux package sysfs import ( "os" "path/filepath" "regexp" ) const sasHostClassPath = "class/sas_host" type SASHost struct { Name string // /sys/class/sas_host/<Name> SASPhys []string // /sys/class/sas_host/<Name>/device/phy-* SASPorts []string // /sys/class/sas_host/<Name>/device/ports-* } type SASHostClass map[string]SASHost var ( sasPhyDeviceRegexp = regexp.MustCompile(`^phy-[0-9:]+$`) sasPortDeviceRegexp = regexp.MustCompile(`^port-[0-9:]+$`) ) // SASHostClass parses host[0-9]+ devices in /sys/class/sas_host. // This generally only exists so that it can pull in SAS Port and SAS // PHY entries. // // The sas_host class doesn't collect any obvious statistics. Each // sas_host contains a scsi_host, which seems to collect a couple // minor stats (ioc_reset_count and reply_queue_count), but they're // not worth collecting at this time. There are more useful SAS stats // in the sas_phy class. func (fs FS) SASHostClass() (SASHostClass, error) { path := fs.sys.Path(sasHostClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, err } shc := make(SASHostClass, len(dirs)) for _, d := range dirs { host, err := fs.parseSASHost(d.Name()) if err != nil { return nil, err } shc[host.Name] = host } return shc, nil } // Parse a single sas_host. func (fs FS) parseSASHost(name string) (SASHost, error) { //path := fs.sys.Path(sasHostClassPath, name) host := SASHost{Name: name} devicepath := fs.sys.Path(filepath.Join(sasHostClassPath, name, "device")) dirs, err := os.ReadDir(devicepath) if err != nil { return nil, err } for _, d := range dirs { if sasPhyDeviceRegexp.MatchString(d.Name()) { host.SASPhys = append(host.SASPhys, d.Name()) } if sasPortDeviceRegexp.MatchString(d.Name()) { host.SASPorts = append(host.SASPorts, d.Name()) } } return &host, nil } // GetByName returns the SASHost with the provided name. func (shc SASHostClass) GetByName(hostName string) SASHost { return (shc)[hostName] } // GetByPhy finds the SASHost that contains the provided PHY name. func (shc SASHostClass) GetByPhy(phyName string) SASHost { for _, h := range shc { for _, p := range h.SASPhys { if p == phyName { return h } } } return nil } // GetByPort finds the SASHost that contains the provided SAS Port name. func (shc SASHostClass) GetByPort(portName string) SASHost { for _, h := range *shc { for _, p := range h.SASPorts { if p == portName { return h } } } return nil }	3.06 KB	2025-05-25 12:27
📄 class_sas_host_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestSASHostClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASHostClass() if err != nil { t.Fatal(err) } want := SASHostClass{ "host11": &SASHost{ Name: "host11", SASPhys: []string{ "phy-11:10", "phy-11:11", "phy-11:12", "phy-11:13", "phy-11:14", "phy-11:15", "phy-11:7", "phy-11:8", "phy-11:9", }, SASPorts: []string{ "port-11:0", "port-11:1", "port-11:2", }, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASHost class (-want +got):\n%s", diff) } } func TestSASHostGetByName(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } hc, err := fs.SASHostClass() if err != nil { t.Fatal(err) } want := "host11" got := hc.GetByName("host11").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASHost class (-want +got):\n%s", diff) } // Doesn't exist. got2 := hc.GetByName("host12") if got2 != nil { t.Fatalf("unexpected GetByName response: got %v want nil", got2) } } func TestSASHostGetByPhy(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } hc, err := fs.SASHostClass() if err != nil { t.Fatal(err) } want := "host11" got := hc.GetByPhy("phy-11:11").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASHost class (-want +got):\n%s", diff) } // Doesn't exist. got2 := hc.GetByPhy("phy-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } } func TestSASHostGetByPort(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } hc, err := fs.SASHostClass() if err != nil { t.Fatal(err) } want := "host11" got := hc.GetByPort("port-11:0").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASHost class (-want +got):\n%s", diff) } // Doesn't exist. got2 := hc.GetByPort("port-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } }	2.69 KB	2025-05-25 12:27
📄 class_sas_phy.go // Copyright 2021 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 linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "strconv" "strings" "github.com/prometheus/procfs/internal/util" ) const sasPhyClassPath = "class/sas_phy" type SASPhy struct { Name string // /sys/class/sas_phy/<Name> SASAddress string // /sys/class/sas_phy/<Name>/sas_address SASPort string // /sys/class/sas_phy/<Name>/device/ports DeviceType string // /sys/class/sas_phy/<Name>/device_type InitiatorPortProtocols []string // /sys/class/sas_phy/<Name>/initiator_port_protocols InvalidDwordCount int // /sys/class/sas_phy/<Name>/invalid_dword_count LossOfDwordSyncCount int // /sys/class/sas_phy/<Name>/loss_of_dword_sync_count MaximumLinkrate float64 // /sys/class/sas_phy/<Name>/maximum_linkrate MaximumLinkrateHW float64 // /sys/class/sas_phy/<Name>/maximum_linkrate_hw MinimumLinkrate float64 // /sys/class/sas_phy/<Name>/minimum_linkrate MinimumLinkrateHW float64 // /sys/class/sas_phy/<Name>/minimum_linkrate_hw NegotiatedLinkrate float64 // /sys/class/sas_phy/<Name>/negotiated_linkrate PhyIdentifier string // /sys/class/sas_phy/<Name>/phy_identifier PhyResetProblemCount int // /sys/class/sas_phy/<Name>/phy_reset_problem_count RunningDisparityErrorCount int // /sys/class/sas_phy/<Name>/running_disparity_error_count TargetPortProtocols []string // /sys/class/sas_phy/<Name>/target_port_protocols } type SASPhyClass map[string]SASPhy // SASPhyClass parses entries in /sys/class/sas_phy. func (fs FS) SASPhyClass() (SASPhyClass, error) { path := fs.sys.Path(sasPhyClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, err } spc := make(SASPhyClass, len(dirs)) for _, d := range dirs { phy, err := fs.parseSASPhy(d.Name()) if err != nil { return nil, err } spc[phy.Name] = phy } return spc, nil } // Parse a single sas_phy. func (fs FS) parseSASPhy(name string) (SASPhy, error) { phy := SASPhy{Name: name} phypath := fs.sys.Path(filepath.Join(sasPhyClassPath, name)) phydevicepath := filepath.Join(phypath, "device") link, err := os.Readlink(filepath.Join(phydevicepath, "port")) if err == nil { if sasPortDeviceRegexp.MatchString(filepath.Base(link)) { phy.SASPort = filepath.Base(link) } } files, err := os.ReadDir(phypath) if err != nil { return nil, err } for _, f := range files { name := filepath.Join(phypath, f.Name()) fileinfo, _ := os.Stat(name) if fileinfo.Mode().IsRegular() { value, err := util.SysReadFile(name) if err != nil { if os.IsPermission(err) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f.Name() { case "sas_address": phy.SASAddress = value case "device_type": phy.DeviceType = value case "initiator_port_protocols": phy.InitiatorPortProtocols = strings.Split(value, ", ") case "invalid_dword_count": phy.InvalidDwordCount = vp.Int() case "loss_of_dword_sync_count": phy.LossOfDwordSyncCount = vp.Int() case "maximum_linkrate": phy.MaximumLinkrate = parseLinkrate(value) case "maximum_linkrate_hw": phy.MaximumLinkrateHW = parseLinkrate(value) case "minimum_linkrate": phy.MinimumLinkrate = parseLinkrate(value) case "minimum_linkrate_hw": phy.MinimumLinkrateHW = parseLinkrate(value) case "negotiated_linkrate": phy.NegotiatedLinkrate = parseLinkrate(value) case "phy_identifier": phy.PhyIdentifier = value case "phy_reset_problem_count": phy.PhyResetProblemCount = vp.Int() case "running_disparity_error_count": phy.RunningDisparityErrorCount = vp.Int() case "target_port_protocols": phy.TargetPortProtocols = strings.Split(value, ", ") } if err := vp.Err(); err != nil { return nil, err } } } return &phy, nil } // parseLinkRate turns the kernel's SAS linkrate values into floats. // The kernel returns values like "12.0 Gbit". Valid speeds are // currently 1.5, 3.0, 6.0, 12.0, and up. This is a float to cover // the 1.5 Gbps case. A value of 0 is returned if the speed can't be // parsed. func parseLinkrate(value string) float64 { f := strings.Split(value, " ")[0] gb, err := strconv.ParseFloat(f, 64) if err != nil { return 0 } return gb } // GetByName returns the SASPhy with the provided name. func (spc SASPhyClass) GetByName(name string) SASPhy { return (*spc)[name] }	5.06 KB	2025-05-25 12:27
📄 class_sas_phy_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestSASPhyClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASPhyClass() if err != nil { t.Fatal(err) } want := SASPhyClass{ "phy-11:0:2": { Name: "phy-11:0:2", SASAddress: "0x5000ccab0200947e", SASPort: "port-11:0:0", DeviceType: "edge expander", InitiatorPortProtocols: []string{"smp"}, InvalidDwordCount: 18, LossOfDwordSyncCount: 1, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 1.5, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "2", RunningDisparityErrorCount: 18, TargetPortProtocols: []string{"smp"}, }, "phy-11:0:4": { Name: "phy-11:0:4", SASAddress: "0x5000ccab0200947e", SASPort: "port-11:0:1", DeviceType: "edge expander", InitiatorPortProtocols: []string{"smp"}, InvalidDwordCount: 1, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 1.5, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "4", RunningDisparityErrorCount: 1, TargetPortProtocols: []string{"smp"}, }, "phy-11:0:6": { Name: "phy-11:0:6", SASAddress: "0x5000ccab0200947e", SASPort: "port-11:0:2", DeviceType: "edge expander", InitiatorPortProtocols: []string{"smp"}, InvalidDwordCount: 19, LossOfDwordSyncCount: 1, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 1.5, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "6", RunningDisparityErrorCount: 20, TargetPortProtocols: []string{"smp"}, }, "phy-11:10": { Name: "phy-11:10", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:0", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "10", TargetPortProtocols: []string{"none"}, }, "phy-11:11": { Name: "phy-11:11", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:0", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "11", TargetPortProtocols: []string{"none"}, }, "phy-11:12": { Name: "phy-11:12", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:1", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "12", TargetPortProtocols: []string{"none"}, }, "phy-11:13": { Name: "phy-11:13", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:1", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "13", TargetPortProtocols: []string{"none"}, }, "phy-11:14": { Name: "phy-11:14", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:1", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "14", TargetPortProtocols: []string{"none"}, }, "phy-11:15": { Name: "phy-11:15", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:1", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 6, PhyIdentifier: "15", TargetPortProtocols: []string{"none"}, }, "phy-11:7": { Name: "phy-11:7", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:2", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "7", TargetPortProtocols: []string{"none"}, }, "phy-11:8": { Name: "phy-11:8", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:0", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "8", TargetPortProtocols: []string{"none"}, }, "phy-11:9": { Name: "phy-11:9", SASAddress: "0x500062b2047b51c4", SASPort: "port-11:0", DeviceType: "end device", InitiatorPortProtocols: []string{"smp", "stp", "ssp"}, MaximumLinkrate: 12, MaximumLinkrateHW: 12, MinimumLinkrate: 3, MinimumLinkrateHW: 1.5, NegotiatedLinkrate: 12, PhyIdentifier: "9", TargetPortProtocols: []string{"none"}, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPhy class (-want +got):\n%s", diff) } } func TestSASPhyGetByName(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } pc, err := fs.SASPhyClass() if err != nil { t.Fatal(err) } want := "phy-11:9" got := pc.GetByName("phy-11:9").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPhy class (-want +got):\n%s", diff) } // Doesn't exist. got2 := pc.GetByName("phy-12:0") if got2 != nil { t.Fatalf("unexpected GetByName response: got %v want nil", got2) } }	7.5 KB	2025-05-25 12:27
📄 class_sas_port.go // Copyright 2021 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 linux // +build linux package sysfs import ( "os" "path/filepath" "regexp" ) const sasPortClassPath = "class/sas_port" type SASPort struct { Name string // /sys/class/sas_device/<Name> SASPhys []string // /sys/class/sas_device/<Name>/device/phy-* Expanders []string // /sys/class/sas_port/<Name>/device/expander-* EndDevices []string // /sys/class/sas_port/<Name>/device/end_device-* } type SASPortClass map[string]SASPort var ( sasExpanderDeviceRegexp = regexp.MustCompile(`^expander-[0-9:]+$`) sasEndDeviceRegexp = regexp.MustCompile(`^end_device-[0-9:]+$`) ) // SASPortClass parses ports in /sys/class/sas_port. // // A SAS port in this context is a collection of SAS PHYs operating // together. For example, it's common to have 8-lane SAS cards that // have 2 external connectors, each of which carries 4 SAS lanes over // a SFF-8088 or SFF-8644 connector. While it's possible to split // those 4 lanes into 4 different cables wired directly into // individual drives, it's more common to connect them all to a SAS // expander. This gives you 4x the bandwidth between the expander and // the SAS host, and is represented by a sas-port object which // contains 4 sas-phy objects. func (fs FS) SASPortClass() (SASPortClass, error) { path := fs.sys.Path(sasPortClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, err } spc := make(SASPortClass, len(dirs)) for _, d := range dirs { port, err := fs.parseSASPort(d.Name()) if err != nil { return nil, err } spc[port.Name] = port } return spc, nil } // Parse a single sas_port. func (fs FS) parseSASPort(name string) (SASPort, error) { port := SASPort{Name: name} portpath := fs.sys.Path(filepath.Join(sasPortClassPath, name, "device")) dirs, err := os.ReadDir(portpath) if err != nil { return nil, err } for _, d := range dirs { if sasPhyDeviceRegexp.MatchString(d.Name()) { port.SASPhys = append(port.SASPhys, d.Name()) } if sasExpanderDeviceRegexp.MatchString(d.Name()) { port.Expanders = append(port.Expanders, d.Name()) } if sasEndDeviceRegexp.MatchString(d.Name()) { port.EndDevices = append(port.EndDevices, d.Name()) } } return &port, nil } // GetByName returns the SASPort with the provided name. func (spc SASPortClass) GetByName(name string) SASPort { return (spc)[name] } // GetByPhy finds the SASPort that contains the provided PHY name. func (spc SASPortClass) GetByPhy(name string) SASPort { for _, d := range spc { for _, p := range d.SASPhys { if p == name { return d } } } return nil } // GetByExpander finds the SASPort that contains the provided SAS expander name. func (spc SASPortClass) GetByExpander(name string) SASPort { for _, d := range spc { for _, e := range d.Expanders { if e == name { return d } } } return nil } // GetByEndDevice finds the SASPort that contains the provided SAS end device name. func (spc SASPortClass) GetByEndDevice(name string) SASPort { for _, d := range spc { for _, e := range d.EndDevices { if e == name { return d } } } return nil }	3.64 KB	2025-05-25 12:27
📄 class_sas_port_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestSASPortClass(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SASPortClass() if err != nil { t.Fatal(err) } want := SASPortClass{ "port-11:0": { Name: "port-11:0", SASPhys: []string{"phy-11:10", "phy-11:11", "phy-11:8", "phy-11:9"}, Expanders: []string{"expander-11:0"}, }, "port-11:0:0": { Name: "port-11:0:0", SASPhys: []string{"phy-11:0:2"}, EndDevices: []string{"end_device-11:0:0"}, }, "port-11:0:1": { Name: "port-11:0:1", SASPhys: []string{"phy-11:0:4"}, EndDevices: []string{"end_device-11:0:1"}, }, "port-11:0:2": { Name: "port-11:0:2", SASPhys: []string{"phy-11:0:6"}, EndDevices: []string{"end_device-11:0:2"}, }, "port-11:1": { Name: "port-11:1", SASPhys: []string{"phy-11:12", "phy-11:13", "phy-11:14", "phy-11:15"}, Expanders: []string{"expander-11:1"}, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASDevice class (-want +got):\n%s", diff) } } func TestSASPortGetByName(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASPortClass() if err != nil { t.Fatal(err) } want := "port-11:0:0" got := dc.GetByName("port-11:0:0").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPort name (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByName("port-15") if got2 != nil { t.Fatalf("unexpected GetByName response: got %v want nil", got2) } } func TestSASPortGetByPhy(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASPortClass() if err != nil { t.Fatal(err) } want := "port-11:0:2" got := dc.GetByPhy("phy-11:0:6").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPort class (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByPhy("phy-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } } func TestSASPortGetByExpander(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASPortClass() if err != nil { t.Fatal(err) } want := "port-11:0" got := dc.GetByExpander("expander-11:0").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPort class (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByExpander("expander-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } } func TestSASPortGetByEndDevice(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } dc, err := fs.SASPortClass() if err != nil { t.Fatal(err) } want := "port-11:0:2" got := dc.GetByEndDevice("end_device-11:0:2").Name if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SASPort class (-want +got):\n%s", diff) } // Doesn't exist. got2 := dc.GetByEndDevice("end_device-12:0") if got2 != nil { t.Fatalf("unexpected GetByPhy response: got %v want nil", got2) } }	3.71 KB	2025-05-25 12:27
📄 class_scsitape.go // Copyright 2021 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 linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "regexp" "github.com/prometheus/procfs/internal/util" ) const scsiTapeClassPath = "class/scsi_tape" type SCSITapeCounters struct { WriteNs uint64 // /sys/class/scsi_tape/<Name>/stats/write_ns ReadByteCnt uint64 // /sys/class/scsi_tape/<Name>/stats/read_byte_cnt IoNs uint64 // /sys/class/scsi_tape/<Name>/stats/io_ns WriteCnt uint64 // /sys/class/scsi_tape/<Name>/stats/write_cnt ResidCnt uint64 // /sys/class/scsi_tape/<Name>/stats/resid_cnt ReadNs uint64 // /sys/class/scsi_tape/<Name>/stats/read_ns InFlight uint64 // /sys/class/scsi_tape/<Name>/stats/in_flight OtherCnt uint64 // /sys/class/scsi_tape/<Name>/stats/other_cnt ReadCnt uint64 // /sys/class/scsi_tape/<Name>/stats/read_cnt WriteByteCnt uint64 // /sys/class/scsi_tape/<Name>/stats/write_byte_cnt } type SCSITape struct { Name string // /sys/class/scsi_tape/<Name> Counters SCSITapeCounters // /sys/class/scsi_tape/<Name>/statistics/* } type SCSITapeClass map[string]SCSITape // SCSITapeClass parses st[0-9]+ devices in /sys/class/scsi_tape. func (fs FS) SCSITapeClass() (SCSITapeClass, error) { path := fs.sys.Path(scsiTapeClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, err } // There are n?st[0-9]+[a-b]? variants depending on device features. // n/2 is probably overestimated but never underestimated stc := make(SCSITapeClass, len(dirs)/2) validDevice := regexp.MustCompile(`^st[0-9]+$`) for _, d := range dirs { if !validDevice.Match([]byte(d.Name())) { continue } tape, err := fs.parseSCSITape(d.Name()) if err != nil { return nil, err } stc[tape.Name] = tape } return stc, nil } // Parse a single scsi_tape. func (fs FS) parseSCSITape(name string) (SCSITape, error) { path := fs.sys.Path(scsiTapeClassPath, name) tape := SCSITape{Name: name} counters, err := parseSCSITapeStatistics(path) if err != nil { return nil, err } tape.Counters = counters return &tape, nil } // parseSCSITapeStatistics parses metrics from a single tape. func parseSCSITapeStatistics(tapePath string) (SCSITapeCounters, error) { var counters SCSITapeCounters path := filepath.Join(tapePath, "stats") files, err := os.ReadDir(path) if err != nil { return nil, err } for _, f := range files { name := filepath.Join(path, f.Name()) value, err := util.SysReadFile(name) if err != nil { return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f.Name() { case "in_flight": counters.InFlight = vp.PUInt64() case "io_ns": counters.IoNs = vp.PUInt64() case "other_cnt": counters.OtherCnt = vp.PUInt64() case "read_byte_cnt": counters.ReadByteCnt = vp.PUInt64() case "read_cnt": counters.ReadCnt = vp.PUInt64() case "read_ns": counters.ReadNs = vp.PUInt64() case "resid_cnt": counters.ResidCnt = vp.PUInt64() case "write_byte_cnt": counters.WriteByteCnt = vp.PUInt64() case "write_cnt": counters.WriteCnt = vp.PUInt64() case "write_ns": counters.WriteNs = vp.PUInt64() } if err := vp.Err(); err != nil { return nil, err } } return &counters, nil }	3.77 KB	2025-05-25 12:27
📄 class_scsitape_test.go // Copyright 2021 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 linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestSCSITapeClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.SCSITapeClass() if err != nil { t.Fatal(err) } want := SCSITapeClass{ "st0": SCSITape{ Name: "st0", Counters: SCSITapeCounters{ WriteNs: 5233597394395, ReadByteCnt: 979383912, IoNs: 9247011087720, WriteCnt: 53772916, WriteByteCnt: 1496246784000, ResidCnt: 19, ReadNs: 33788355744, InFlight: 1, OtherCnt: 1409, ReadCnt: 3741, }, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected SCSITape class (-want +got):\n%s", diff) } }	1.34 KB	2025-05-25 12:27
📄 class_thermal.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "errors" "os" "path/filepath" "strings" "syscall" "github.com/prometheus/procfs/internal/util" fsp "io/fs" ) // ClassThermalZoneStats contains info from files in /sys/class/thermal/thermal_zone<zone> // for a single <zone>. // https://www.kernel.org/doc/Documentation/thermal/sysfs-api.txt type ClassThermalZoneStats struct { Name string // The name of the zone from the directory structure. Type string // The type of thermal zone. 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) } // ClassThermalZoneStats returns Thermal Zone metrics for all zones. func (fs FS) ClassThermalZoneStats() ([]ClassThermalZoneStats, error) { zones, err := filepath.Glob(fs.sys.Path("class/thermal/thermal_zone[0-9]")) if err != nil { return nil, err } stats := make([]ClassThermalZoneStats, 0, len(zones)) for _, zone := range zones { zoneStats, err := parseClassThermalZone(zone) if err != nil { if errors.Is(err, syscall.ENODATA) \|\| errors.As(err, new(fsp.PathError)) { continue } return nil, err } zoneStats.Name = strings.TrimPrefix(filepath.Base(zone), "thermal_zone") stats = append(stats, zoneStats) } return stats, nil } func parseClassThermalZone(zone string) (ClassThermalZoneStats, error) { // Required attributes. zoneType, err := util.SysReadFile(filepath.Join(zone, "type")) if err != nil { return ClassThermalZoneStats{}, err } zonePolicy, err := util.SysReadFile(filepath.Join(zone, "policy")) if err != nil { return ClassThermalZoneStats{}, err } zoneTemp, err := util.ReadIntFromFile(filepath.Join(zone, "temp")) if err != nil { return ClassThermalZoneStats{}, err } // Optional attributes. mode, err := util.SysReadFile(filepath.Join(zone, "mode")) if err != nil && !os.IsNotExist(err) && !os.IsPermission(err) { return ClassThermalZoneStats{}, err } zoneMode := util.ParseBool(mode) var zonePassive *uint64 passive, err := util.ReadUintFromFile(filepath.Join(zone, "passive")) if os.IsNotExist(err) \|\| os.IsPermission(err) { zonePassive = nil } else if err != nil { return ClassThermalZoneStats{}, err } else { zonePassive = &passive } return ClassThermalZoneStats{ Type: zoneType, Policy: zonePolicy, Temp: zoneTemp, Mode: zoneMode, Passive: zonePassive, }, nil }	3.13 KB	2025-05-25 12:27
📄 class_thermal_test.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "reflect" "testing" "github.com/prometheus/procfs/internal/util" ) func TestClassThermalZoneStats(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } thermalTest, err := fs.ClassThermalZoneStats() if err != nil { t.Fatal(err) } enabled := util.ParseBool("enabled") passive := uint64(0) classThermalZoneStats := []ClassThermalZoneStats{ { Name: "0", Type: "bcm2835_thermal", Policy: "step_wise", Temp: 49925, Mode: nil, Passive: nil, }, { Name: "1", Type: "acpitz", Policy: "step_wise", Temp: -44000, Mode: enabled, Passive: &passive, }, } if !reflect.DeepEqual(classThermalZoneStats, thermalTest) { t.Errorf("Result not correct: want %v, have %v", classThermalZoneStats, thermalTest) } }	1.43 KB	2025-05-25 12:27
📄 class_watchdog.go // Copyright 2023 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "github.com/prometheus/procfs/internal/util" ) const watchdogClassPath = "class/watchdog" // WatchdogStats contains info from files in /sys/class/watchdog for a single watchdog device. // https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-class-watchdog type WatchdogStats struct { Name string Bootstatus int64 // /sys/class/watchdog/<Name>/bootstatus Options string // /sys/class/watchdog/<Name>/options FwVersion int64 // /sys/class/watchdog/<Name>/fw_version Identity string // /sys/class/watchdog/<Name>/identity Nowayout int64 // /sys/class/watchdog/<Name>/nowayout State string // /sys/class/watchdog/<Name>/state Status string // /sys/class/watchdog/<Name>/status Timeleft int64 // /sys/class/watchdog/<Name>/timeleft Timeout int64 // /sys/class/watchdog/<Name>/timeout Pretimeout int64 // /sys/class/watchdog/<Name>/pretimeout PretimeoutGovernor string // /sys/class/watchdog/<Name>/pretimeout_governor AccessCs0 int64 // /sys/class/watchdog/<Name>/access_cs0 } // WatchdogClass is a collection of statistics for every watchdog device in /sys/class/watchdog. // // The map keys are the names of the watchdog devices. type WatchdogClass map[string]WatchdogStats // WatchdogClass returns info for all watchdog devices read from /sys/class/watchdog. func (fs FS) WatchdogClass() (WatchdogClass, error) { path := fs.sys.Path(watchdogClassPath) dirs, err := os.ReadDir(path) if err != nil { return nil, fmt.Errorf("failed to list watchdog devices at %q: %w", path, err) } wds := make(WatchdogClass, len(dirs)) for _, d := range dirs { stats, err := fs.parseWatchdog(d.Name()) if err != nil { return nil, err } wds[stats.Name] = stats } return wds, nil } func (fs FS) parseWatchdog(wdName string) (WatchdogStats, error) { path := fs.sys.Path(watchdogClassPath, wdName) wd := WatchdogStats{Name: wdName} for _, f := range [...]string{"bootstatus", "options", "fw_version", "identity", "nowayout", "state", "status", "timeleft", "timeout", "pretimeout", "pretimeout_governor", "access_cs0"} { name := filepath.Join(path, f) value, err := util.SysReadFile(name) if err != nil { if os.IsNotExist(err) { continue } return nil, fmt.Errorf("failed to read file %q: %w", name, err) } vp := util.NewValueParser(value) switch f { case "bootstatus": wd.Bootstatus = vp.PInt64() case "options": wd.Options = &value case "fw_version": wd.FwVersion = vp.PInt64() case "identity": wd.Identity = &value case "nowayout": wd.Nowayout = vp.PInt64() case "state": wd.State = &value case "status": wd.Status = &value case "timeleft": wd.Timeleft = vp.PInt64() case "timeout": wd.Timeout = vp.PInt64() case "pretimeout": wd.Pretimeout = vp.PInt64() case "pretimeout_governor": wd.PretimeoutGovernor = &value case "access_cs0": wd.AccessCs0 = vp.PInt64() } if err := vp.Err(); err != nil { return nil, err } } return &wd, nil }	3.7 KB	2025-05-25 12:27
📄 class_watchdog_test.go // Copyright 2023 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestWatchdogClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.WatchdogClass() if err != nil { t.Fatal(err) } var ( bootstatus int64 = 1 fwVersion int64 = 2 nowayout int64 timeleft int64 = 300 timeout int64 = 60 pretimeout int64 = 120 accessCs0 int64 options = "0x8380" identity = "Software Watchdog" state = "active" status = "0x8000" pretimeoutGovernor = "noop" ) want := WatchdogClass{ "watchdog0": { Name: "watchdog0", Bootstatus: &bootstatus, Options: &options, FwVersion: &fwVersion, Identity: &identity, Nowayout: &nowayout, State: &state, Status: &status, Timeleft: &timeleft, Timeout: &timeout, Pretimeout: &pretimeout, PretimeoutGovernor: &pretimeoutGovernor, AccessCs0: &accessCs0, }, "watchdog1": { Name: "watchdog1", }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected watchdog class (-want +got):\n%s", diff) } }	1.83 KB	2025-05-25 12:27
📄 clocksource.go // 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. //go:build linux // +build linux package sysfs import ( "path/filepath" "strings" "github.com/prometheus/procfs/internal/util" ) // ClockSource contains metrics related to the clock source. type ClockSource struct { Name string Available []string Current string } // ClockSources returns clocksource information including current and available clocksources // read from '/sys/devices/system/clocksource'. func (fs FS) ClockSources() ([]ClockSource, error) { clocksourcePaths, err := filepath.Glob(fs.sys.Path("devices/system/clocksource/clocksource[0-9]")) if err != nil { return nil, err } clocksources := make([]ClockSource, len(clocksourcePaths)) for i, clocksourcePath := range clocksourcePaths { clocksourceName := strings.TrimPrefix(filepath.Base(clocksourcePath), "clocksource") clocksource, err := parseClocksource(clocksourcePath) if err != nil { return nil, err } clocksource.Name = clocksourceName clocksources[i] = clocksource } return clocksources, nil } func parseClocksource(clocksourcePath string) (*ClockSource, error) { stringFiles := []string{ "available_clocksource", "current_clocksource", } stringOut := make([]string, len(stringFiles)) var err error for i, f := range stringFiles { stringOut[i], err = util.SysReadFile(filepath.Join(clocksourcePath, f)) if err != nil { return &ClockSource{}, err } } return &ClockSource{ Available: strings.Fields(stringOut[0]), Current: stringOut[1], }, nil }	2.04 KB	2025-05-25 12:27
📄 clocksource_test.go // 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. //go:build linux // +build linux package sysfs import ( "reflect" "testing" ) func TestNewClocksource(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } c, err := fs.ClockSources() if err != nil { t.Fatal(err) } clocksources := []ClockSource{ { Name: "0", Available: []string{"tsc", "hpet", "acpi_pm"}, Current: "tsc", }, } if !reflect.DeepEqual(clocksources, c) { t.Errorf("Result not correct: want %v, have %v", clocksources, c) } }	1.08 KB	2025-05-25 12:27
📄 doc.go // Copyright 2017 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 linux // +build linux // Package sysfs provides functions to retrieve system and kernel metrics // from the pseudo-filesystem sys. package sysfs	750 B	2025-05-25 12:27
📄 fs.go // Copyright 2017 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 linux // +build linux package sysfs import ( "github.com/prometheus/procfs/internal/fs" ) // FS represents the pseudo-filesystem sys, which provides an interface to // kernel data structures. type FS struct { sys fs.FS } // DefaultMountPoint is the common mount point of the sys filesystem. const DefaultMountPoint = fs.DefaultSysMountPoint // NewDefaultFS returns a new FS mounted under the default mountPoint. It will error // if the mount point can't be read. func NewDefaultFS() (FS, error) { return NewFS(DefaultMountPoint) } // NewFS returns a new FS mounted under the given mountPoint. It will error // if the mount point can't be read. func NewFS(mountPoint string) (FS, error) { fs, err := fs.NewFS(mountPoint) if err != nil { return FS{}, err } return FS{fs}, nil }	1.36 KB	2025-05-25 12:27
📄 fs_test.go // Copyright 2017 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 linux // +build linux package sysfs import "testing" const ( sysTestFixtures = "testdata/fixtures/sys" ) func TestNewFS(t *testing.T) { if _, err := NewFS("foobar"); err == nil { t.Error("want NewFS to fail for non-existing mount point") } if _, err := NewFS("doc.go"); err == nil { t.Error("want NewFS to fail if mount point is not a directory") } if _, err := NewFS(sysTestFixtures); err != nil { t.Error("want NewFS to succeed if mount point exists") } }	1.06 KB	2025-05-25 12:27
📄 mdraid.go // Copyright 2023 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "fmt" "path/filepath" "strings" "github.com/prometheus/procfs/internal/util" ) // Mdraid holds info parsed from relevant files in the /sys/block/md/md directory. type Mdraid struct { Device string // Kernel device name of array. Level string // mdraid level. ArrayState string // State of the array. MetadataVersion string // mdraid metadata version. Disks uint64 // Number of devices in a fully functional array. Components []MdraidComponent // mdraid component devices. UUID string // UUID of the array. // The following item is only valid for raid0, 4, 5, 6 and 10. ChunkSize uint64 // Chunk size // The following items are only valid for raid1, 4, 5, 6 and 10. DegradedDisks uint64 // Number of degraded disks in the array. SyncAction string // Current sync action. SyncCompleted float64 // Fraction (0-1) representing the completion status of current sync operation. } type MdraidComponent struct { Device string // Kernel device name. State string // Current state of device. } // Mdraids gathers information and statistics about mdraid devices present. Based on upstream // kernel documentation https://docs.kernel.org/admin-guide/md.html. func (fs FS) Mdraids() ([]Mdraid, error) { matches, err := filepath.Glob(fs.sys.Path("block/md/md")) if err != nil { return nil, err } mdraids := make([]Mdraid, 0) for _, m := range matches { md := Mdraid{Device: filepath.Base(filepath.Dir(m))} path := fs.sys.Path("block", md.Device, "md") if val, err := util.SysReadFile(filepath.Join(path, "level")); err == nil { md.Level = val } else { return mdraids, err } // Array state can be one of: clear, inactive, readonly, read-auto, clean, active, // write-pending, active-idle. if val, err := util.SysReadFile(filepath.Join(path, "array_state")); err == nil { md.ArrayState = val } else { return mdraids, err } if val, err := util.SysReadFile(filepath.Join(path, "metadata_version")); err == nil { md.MetadataVersion = val } else { return mdraids, err } if val, err := util.ReadUintFromFile(filepath.Join(path, "raid_disks")); err == nil { md.Disks = val } else { return mdraids, err } if val, err := util.SysReadFile(filepath.Join(path, "uuid")); err == nil { md.UUID = val } else { return mdraids, err } if devs, err := filepath.Glob(filepath.Join(path, "dev-*")); err == nil { for _, dev := range devs { comp := MdraidComponent{Device: strings.TrimPrefix(filepath.Base(dev), "dev-")} // Component state can be a comma-separated list of: faulty, in_sync, writemostly, // blocked, spare, write_error, want_replacement, replacement. if val, err := util.SysReadFile(filepath.Join(dev, "state")); err == nil { comp.State = val } else { return mdraids, err } md.Components = append(md.Components, comp) } } else { return mdraids, err } switch md.Level { case "raid0", "raid4", "raid5", "raid6", "raid10": if val, err := util.ReadUintFromFile(filepath.Join(path, "chunk_size")); err == nil { md.ChunkSize = val } else { return mdraids, err } } switch md.Level { case "raid1", "raid4", "raid5", "raid6", "raid10": if val, err := util.ReadUintFromFile(filepath.Join(path, "degraded")); err == nil { md.DegradedDisks = val } else { return mdraids, err } // Array sync action can be one of: resync, recover, idle, check, repair. if val, err := util.SysReadFile(filepath.Join(path, "sync_action")); err == nil { md.SyncAction = val } else { return mdraids, err } if val, err := util.SysReadFile(filepath.Join(path, "sync_completed")); err == nil { if val != "none" { var a, b uint64 // File contains two values representing the fraction of number of completed // sectors divided by number of total sectors to process. if _, err := fmt.Sscanf(val, "%d / %d", &a, &b); err == nil { md.SyncCompleted = float64(a) / float64(b) } else { return mdraids, err } } } else { return mdraids, err } } mdraids = append(mdraids, md) } return mdraids, nil }	4.79 KB	2025-05-25 12:27
📄 mdraid_test.go // Copyright 2023 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "testing" "github.com/google/go-cmp/cmp" ) func TestMdraidStats(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } got, err := fs.Mdraids() if err != nil { t.Fatal(err) } want := []Mdraid{ { Device: "md0", Level: "raid0", ArrayState: "clean", MetadataVersion: "1.2", Disks: 2, Components: []MdraidComponent{ {Device: "sdg", State: "in_sync"}, {Device: "sdh", State: "in_sync"}, }, UUID: "155f29ff-1716-4107-b362-52307ef86cac", ChunkSize: 524288, }, { Device: "md1", Level: "raid1", ArrayState: "clean", MetadataVersion: "1.2", Disks: 2, Components: []MdraidComponent{ {Device: "sdi", State: "in_sync"}, {Device: "sdj", State: "in_sync"}, }, UUID: "0fbf5f2c-add2-43c2-bd78-a4be3ab709ef", SyncAction: "idle", }, { Device: "md10", Level: "raid10", ArrayState: "clean", MetadataVersion: "1.2", Disks: 4, Components: []MdraidComponent{ {Device: "sdu", State: "in_sync"}, {Device: "sdv", State: "in_sync"}, {Device: "sdw", State: "in_sync"}, {Device: "sdx", State: "in_sync"}, }, UUID: "0c15f7e7-b159-4b1f-a5cd-a79b5c04b6f5", ChunkSize: 524288, SyncAction: "idle", }, { Device: "md4", Level: "raid4", ArrayState: "clean", MetadataVersion: "1.2", Disks: 3, Components: []MdraidComponent{ {Device: "sdk", State: "in_sync"}, {Device: "sdl", State: "in_sync"}, {Device: "sdm", State: "in_sync"}, }, UUID: "67f415d5-2c0c-4b69-8e0d-7e20ef553457", ChunkSize: 524288, SyncAction: "idle", }, { Device: "md5", Level: "raid5", ArrayState: "clean", MetadataVersion: "1.2", Disks: 3, Components: []MdraidComponent{ {Device: "sdaa", State: "spare"}, {Device: "sdn", State: "in_sync"}, {Device: "sdo", State: "in_sync"}, {Device: "sdp", State: "faulty"}, }, UUID: "7615b98d-f2ba-4d99-bee8-6202d8e130b9", ChunkSize: 524288, DegradedDisks: 1, SyncAction: "idle", }, { Device: "md6", Level: "raid6", ArrayState: "active", MetadataVersion: "1.2", Disks: 4, Components: []MdraidComponent{ {Device: "sdq", State: "in_sync"}, {Device: "sdr", State: "in_sync"}, {Device: "sds", State: "in_sync"}, {Device: "sdt", State: "spare"}, }, UUID: "5f529b25-6efd-46e4-99a2-31f6f597be6b", ChunkSize: 524288, DegradedDisks: 1, SyncAction: "recover", SyncCompleted: 0.7500458659491194, }, } if diff := cmp.Diff(want, got); diff != "" { t.Fatalf("unexpected Mdraid (-want +got):\n%s", diff) } }	3.42 KB	2025-05-25 12:27
📄 net_class.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "errors" "fmt" "os" "path/filepath" "syscall" "github.com/prometheus/procfs/internal/util" ) const netclassPath = "class/net" // NetClassIface contains info from files in /sys/class/net/<iface> // for single interface (iface). type NetClassIface struct { Name string // Interface name AddrAssignType int64 // /sys/class/net/<iface>/addr_assign_type AddrLen int64 // /sys/class/net/<iface>/addr_len Address string // /sys/class/net/<iface>/address Broadcast string // /sys/class/net/<iface>/broadcast Carrier int64 // /sys/class/net/<iface>/carrier CarrierChanges int64 // /sys/class/net/<iface>/carrier_changes CarrierUpCount int64 // /sys/class/net/<iface>/carrier_up_count CarrierDownCount int64 // /sys/class/net/<iface>/carrier_down_count DevID int64 // /sys/class/net/<iface>/dev_id Dormant int64 // /sys/class/net/<iface>/dormant Duplex string // /sys/class/net/<iface>/duplex Flags int64 // /sys/class/net/<iface>/flags IfAlias string // /sys/class/net/<iface>/ifalias IfIndex int64 // /sys/class/net/<iface>/ifindex IfLink int64 // /sys/class/net/<iface>/iflink LinkMode int64 // /sys/class/net/<iface>/link_mode MTU int64 // /sys/class/net/<iface>/mtu NameAssignType int64 // /sys/class/net/<iface>/name_assign_type NetDevGroup int64 // /sys/class/net/<iface>/netdev_group OperState string // /sys/class/net/<iface>/operstate PhysPortID string // /sys/class/net/<iface>/phys_port_id PhysPortName string // /sys/class/net/<iface>/phys_port_name PhysSwitchID string // /sys/class/net/<iface>/phys_switch_id Speed int64 // /sys/class/net/<iface>/speed TxQueueLen int64 // /sys/class/net/<iface>/tx_queue_len Type int64 // /sys/class/net/<iface>/type } // NetClass is collection of info for every interface (iface) in /sys/class/net. The map keys // are interface (iface) names. type NetClass map[string]NetClassIface // NetClassDevices scans /sys/class/net for devices and returns them as a list of names. func (fs FS) NetClassDevices() ([]string, error) { var res []string path := fs.sys.Path(netclassPath) devices, err := os.ReadDir(path) if err != nil { return res, fmt.Errorf("cannot access dir %q: %w", path, err) } for _, deviceDir := range devices { if deviceDir.Type().IsRegular() { continue } res = append(res, deviceDir.Name()) } return res, nil } // NetClassByIface returns info for a single net interfaces (iface). func (fs FS) NetClassByIface(devicePath string) (NetClassIface, error) { path := fs.sys.Path(netclassPath) interfaceClass, err := parseNetClassIface(filepath.Join(path, devicePath)) if err != nil { return nil, err } interfaceClass.Name = devicePath return interfaceClass, nil } // NetClass returns info for all net interfaces (iface) read from /sys/class/net/<iface>. func (fs FS) NetClass() (NetClass, error) { devices, err := fs.NetClassDevices() if err != nil { return nil, err } path := fs.sys.Path(netclassPath) netClass := NetClass{} for _, devicePath := range devices { interfaceClass, err := parseNetClassIface(filepath.Join(path, devicePath)) if err != nil { return nil, err } interfaceClass.Name = devicePath netClass[devicePath] = interfaceClass } return netClass, nil } // canIgnoreError returns true if the error is non-fatal and can be ignored. // Some kernels and some devices don't expose specific attributes or return // errors when reading those attributes; we can ignore these errors and the // attribute that caused them. func canIgnoreError(err error) bool { var errno syscall.Errno if os.IsNotExist(err) { return true } else if os.IsPermission(err) { return true } else if err.Error() == "operation not supported" { return true } else if errors.Is(err, os.ErrInvalid) { return true } else if errors.As(err, &errno) && (errno == syscall.EINVAL) { return true } // all other errors are fatal return false } // ParseNetClassAttribute parses a given file in /sys/class/net/<iface> // and sets the value in a given NetClassIface object if the value was readable. // It returns an error if the file cannot be read and the error is fatal. func ParseNetClassAttribute(devicePath, attrName string, interfaceClass NetClassIface) error { attrPath := filepath.Join(devicePath, attrName) value, err := util.SysReadFile(attrPath) if err != nil { if canIgnoreError(err) { return nil } return fmt.Errorf("failed to read file %q: %w", attrPath, err) } vp := util.NewValueParser(value) switch attrName { case "addr_assign_type": interfaceClass.AddrAssignType = vp.PInt64() case "addr_len": interfaceClass.AddrLen = vp.PInt64() case "address": interfaceClass.Address = value case "broadcast": interfaceClass.Broadcast = value case "carrier": interfaceClass.Carrier = vp.PInt64() case "carrier_changes": interfaceClass.CarrierChanges = vp.PInt64() case "carrier_up_count": interfaceClass.CarrierUpCount = vp.PInt64() case "carrier_down_count": interfaceClass.CarrierDownCount = vp.PInt64() case "dev_id": interfaceClass.DevID = vp.PInt64() case "dormant": interfaceClass.Dormant = vp.PInt64() case "duplex": interfaceClass.Duplex = value case "flags": interfaceClass.Flags = vp.PInt64() case "ifalias": interfaceClass.IfAlias = value case "ifindex": interfaceClass.IfIndex = vp.PInt64() case "iflink": interfaceClass.IfLink = vp.PInt64() case "link_mode": interfaceClass.LinkMode = vp.PInt64() case "mtu": interfaceClass.MTU = vp.PInt64() case "name_assign_type": interfaceClass.NameAssignType = vp.PInt64() case "netdev_group": interfaceClass.NetDevGroup = vp.PInt64() case "operstate": interfaceClass.OperState = value case "phys_port_id": interfaceClass.PhysPortID = value case "phys_port_name": interfaceClass.PhysPortName = value case "phys_switch_id": interfaceClass.PhysSwitchID = value case "speed": interfaceClass.Speed = vp.PInt64() case "tx_queue_len": interfaceClass.TxQueueLen = vp.PInt64() case "type": interfaceClass.Type = vp.PInt64() default: return nil } return nil } // parseNetClassIface scans predefined files in /sys/class/net/<iface> // directory and gets their contents. func parseNetClassIface(devicePath string) (NetClassIface, error) { interfaceClass := NetClassIface{} files, err := os.ReadDir(devicePath) if err != nil { return nil, err } for _, f := range files { if !f.Type().IsRegular() { continue } if err := ParseNetClassAttribute(devicePath, f.Name(), &interfaceClass); err != nil { return nil, err } } return &interfaceClass, nil }	7.25 KB	2025-05-25 12:27
📄 net_class_test.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "reflect" "testing" ) func TestNewNetClassDevices(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } devices, err := fs.NetClassDevices() if err != nil { t.Fatal(err) } if len(devices) != 1 { t.Errorf("Unexpected number of devices, want %d, have %d", 1, len(devices)) } if devices[0] != "eth0" { t.Errorf("Found unexpected device, want %s, have %s", "eth0", devices[0]) } } func TestNewNetClassDevicesByIface(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } _, err = fs.NetClassByIface("non-existent") if err == nil { t.Fatal("expected error, have none") } device, err := fs.NetClassByIface("eth0") if err != nil { t.Fatal(err) } if device.Name != "eth0" { t.Errorf("Found unexpected device, want %s, have %s", "eth0", device.Name) } } func TestNetClass(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } nc, err := fs.NetClass() if err != nil { t.Fatal(err) } var ( addrAssignType int64 = 3 addrLen int64 = 6 carrier int64 = 1 carrierChanges int64 = 2 carrierDownCount int64 = 1 carrierUpCount int64 = 1 devID int64 = 32 dormant int64 = 1 flags int64 = 4867 ifIndex int64 = 2 ifLink int64 = 2 linkMode int64 = 1 mtu int64 = 1500 nameAssignType int64 = 2 netDevGroup int64 speed int64 = 1000 txQueueLen int64 = 1000 netType int64 = 1 ) netClass := NetClass{ "eth0": { Address: "01:01:01:01:01:01", AddrAssignType: &addrAssignType, AddrLen: &addrLen, Broadcast: "ff:ff:ff:ff:ff:ff", Carrier: &carrier, CarrierChanges: &carrierChanges, CarrierDownCount: &carrierDownCount, CarrierUpCount: &carrierUpCount, DevID: &devID, Dormant: &dormant, Duplex: "full", Flags: &flags, IfAlias: "", IfIndex: &ifIndex, IfLink: &ifLink, LinkMode: &linkMode, MTU: &mtu, Name: "eth0", NameAssignType: &nameAssignType, NetDevGroup: &netDevGroup, OperState: "up", PhysPortID: "", PhysPortName: "", PhysSwitchID: "", Speed: &speed, TxQueueLen: &txQueueLen, Type: &netType, }, } if !reflect.DeepEqual(netClass, nc) { t.Errorf("Result not correct: want %v, have %v", netClass, nc) } }	3.14 KB	2025-05-25 12:27
📄 system_cpu.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "fmt" "os" "path/filepath" "strconv" "strings" "golang.org/x/sync/errgroup" "github.com/prometheus/procfs/internal/util" ) // CPU represents a path to a CPU located in `/sys/devices/system/cpu/cpu[0-9]`. type CPU string // Number returns the ID number of the given CPU. func (c CPU) Number() string { return strings.TrimPrefix(filepath.Base(string(c)), "cpu") } // CPUTopology contains data located in `/sys/devices/system/cpu/cpu[0-9]/topology`. type CPUTopology struct { CoreID string CoreSiblingsList string PhysicalPackageID string ThreadSiblingsList string } // CPUThermalThrottle contains data from `/sys/devices/system/cpu/cpu[0-9]/thermal_throttle`. type CPUThermalThrottle struct { CoreThrottleCount uint64 PackageThrottleCount uint64 } // SystemCPUCpufreqStats contains stats from `/sys/devices/system/cpu/cpu[0-9]/cpufreq/...`. type SystemCPUCpufreqStats struct { Name string CpuinfoCurrentFrequency uint64 CpuinfoMinimumFrequency uint64 CpuinfoMaximumFrequency uint64 CpuinfoTransitionLatency uint64 ScalingCurrentFrequency uint64 ScalingMinimumFrequency uint64 ScalingMaximumFrequency uint64 AvailableGovernors string Driver string Governor string RelatedCpus string SetSpeed string // Refer `CONFIG_CPU_FREQ_STAT`: https://www.kernel.org/doc/html/latest/cpu-freq/cpufreq-stats.html#configuring-cpufreq-stats CpuinfoFrequencyDuration map[uint64]uint64 CpuinfoFrequencyTransitionsTotal uint64 CpuinfoTransitionTable [][]uint64 } // CPUs returns a slice of all CPUs in `/sys/devices/system/cpu`. func (fs FS) CPUs() ([]CPU, error) { cpuPaths, err := filepath.Glob(fs.sys.Path("devices/system/cpu/cpu[0-9]")) if err != nil { return nil, err } cpus := make([]CPU, len(cpuPaths)) for i, cpu := range cpuPaths { cpus[i] = CPU(cpu) } return cpus, nil } // Topology gets the topology information for a single CPU from `/sys/devices/system/cpu/cpuN/topology`. func (c CPU) Topology() (CPUTopology, error) { cpuTopologyPath := filepath.Join(string(c), "topology") if _, err := os.Stat(cpuTopologyPath); err != nil { return nil, err } t, err := parseCPUTopology(cpuTopologyPath) if err != nil { return nil, err } return t, nil } func parseCPUTopology(cpuPath string) (CPUTopology, error) { t := CPUTopology{} var err error t.CoreID, err = util.SysReadFile(filepath.Join(cpuPath, "core_id")) if err != nil { return nil, err } t.PhysicalPackageID, err = util.SysReadFile(filepath.Join(cpuPath, "physical_package_id")) if err != nil { return nil, err } t.CoreSiblingsList, err = util.SysReadFile(filepath.Join(cpuPath, "core_siblings_list")) if err != nil { return nil, err } t.ThreadSiblingsList, err = util.SysReadFile(filepath.Join(cpuPath, "thread_siblings_list")) if err != nil { return nil, err } return &t, nil } // ThermalThrottle gets the cpu throttle count information for a single CPU from `/sys/devices/system/cpu/cpuN/thermal_throttle`. func (c CPU) ThermalThrottle() (CPUThermalThrottle, error) { cpuPath := filepath.Join(string(c), "thermal_throttle") if _, err := os.Stat(cpuPath); err != nil { return nil, err } t, err := parseCPUThermalThrottle(cpuPath) if err != nil { return nil, err } return t, nil } func parseCPUThermalThrottle(cpuPath string) (CPUThermalThrottle, error) { t := CPUThermalThrottle{} var err error t.PackageThrottleCount, err = util.ReadUintFromFile(filepath.Join(cpuPath, "package_throttle_count")) if err != nil { return nil, err } t.CoreThrottleCount, err = util.ReadUintFromFile(filepath.Join(cpuPath, "core_throttle_count")) if err != nil { return nil, err } return &t, nil } func binSearch(elem uint16, elemSlice []uint16) bool { if len(elemSlice) == 0 { return false } if len(elemSlice) == 1 { return elem == (elemSlice)[0] } start := 0 end := len(elemSlice) - 1 var mid int for start <= end { mid = (start + end) / 2 if (elemSlice)[mid] == elem { return true } else if (elemSlice)[mid] > elem { end = mid - 1 } else if (elemSlice)[mid] < elem { start = mid + 1 } } return false } func filterOfflineCPUs(offlineCpus []uint16, cpus []string) ([]string, error) { var filteredCPUs []string for _, cpu := range cpus { cpuName := strings.TrimPrefix(filepath.Base(cpu), "cpu") cpuNameUint16, err := strconv.Atoi(cpuName) if err != nil { return nil, err } if !binSearch(uint16(cpuNameUint16), offlineCpus) { filteredCPUs = append(filteredCPUs, cpu) } } return filteredCPUs, nil } // SystemCpufreq returns CPU frequency metrics for all CPUs. func (fs FS) SystemCpufreq() ([]SystemCPUCpufreqStats, error) { var g errgroup.Group cpus, err := filepath.Glob(fs.sys.Path("devices/system/cpu/cpu[0-9]")) if err != nil { return nil, err } line, err := util.ReadFileNoStat(fs.sys.Path("devices/system/cpu/offline")) if err != nil { return nil, err } if strings.TrimSpace(string(line)) != "" { offlineCPUs, err := parseCPURange(line) if err != nil { return nil, err } if len(offlineCPUs) > 0 { cpus, err = filterOfflineCPUs(&offlineCPUs, &cpus) if err != nil { return nil, err } } } systemCpufreq := make([]SystemCPUCpufreqStats, len(cpus)) for i, cpu := range cpus { cpuName := strings.TrimPrefix(filepath.Base(cpu), "cpu") cpuCpufreqPath := filepath.Join(cpu, "cpufreq") _, err = os.Stat(cpuCpufreqPath) if os.IsNotExist(err) { continue } else if err != nil { return nil, err } // Execute the parsing of each CPU in parallel. // This is done because the kernel intentionally delays access to each CPU by // 50 milliseconds to avoid DDoSing possibly expensive functions. i := i // https://golang.org/doc/faq#closures_and_goroutines g.Go(func() error { cpufreq, err := parseCpufreqCpuinfo(cpuCpufreqPath) if err == nil { cpufreq.Name = cpuName systemCpufreq[i] = cpufreq } return err }) } if err = g.Wait(); err != nil { return nil, err } if len(systemCpufreq) == 0 { return nil, fmt.Errorf("could not find any cpufreq files: %w", os.ErrNotExist) } return systemCpufreq, nil } func parseCpufreqCpuinfo(cpuPath string) (SystemCPUCpufreqStats, error) { uintFiles := []string{ "cpuinfo_cur_freq", "cpuinfo_max_freq", "cpuinfo_min_freq", "cpuinfo_transition_latency", "scaling_cur_freq", "scaling_max_freq", "scaling_min_freq", } uintOut := make([]uint64, len(uintFiles)) for i, f := range uintFiles { v, err := util.ReadUintFromFile(filepath.Join(cpuPath, f)) if err != nil { if os.IsNotExist(err) \|\| os.IsPermission(err) { continue } return &SystemCPUCpufreqStats{}, err } uintOut[i] = &v } stringFiles := []string{ "scaling_available_governors", "scaling_driver", "scaling_governor", "related_cpus", "scaling_setspeed", } stringOut := make([]string, len(stringFiles)) var err error for i, f := range stringFiles { stringOut[i], err = util.SysReadFile(filepath.Join(cpuPath, f)) if err != nil { return &SystemCPUCpufreqStats{}, err } } // "total_trans" is the total number of times the CPU has changed frequency. var cpuinfoFrequencyTransitionsTotal uint64 cpuinfoFrequencyTransitionsTotalUint, err := util.ReadUintFromFile(filepath.Join(cpuPath, "stats", "total_trans")) if err != nil { if !(os.IsNotExist(err) \|\| os.IsPermission(err)) { return &SystemCPUCpufreqStats{}, err } } else { cpuinfoFrequencyTransitionsTotal = &cpuinfoFrequencyTransitionsTotalUint } // "time_in_state" is the total time spent at each frequency. var cpuinfoFrequencyDuration map[uint64]uint64 cpuinfoFrequencyDurationString, err := util.ReadFileNoStat(filepath.Join(cpuPath, "stats", "time_in_state")) if err != nil { if !(os.IsNotExist(err) \|\| os.IsPermission(err)) { return &SystemCPUCpufreqStats{}, err } } else { cpuinfoFrequencyDuration = &map[uint64]uint64{} for _, line := range strings.Split(string(cpuinfoFrequencyDurationString), "\n") { if line == "" { continue } fields := strings.Fields(line) if len(fields) != 2 { return &SystemCPUCpufreqStats{}, fmt.Errorf("unexpected number of fields in time_in_state: %v", fields) } freq, err := strconv.ParseUint(fields[0], 10, 64) if err != nil { return &SystemCPUCpufreqStats{}, err } duration, err := strconv.ParseUint(fields[1], 10, 64) if err != nil { return &SystemCPUCpufreqStats{}, err } (cpuinfoFrequencyDuration)[freq] = duration } } // "trans_table" contains information about all the CPU frequency transitions. var cpuinfoTransitionTable [][]uint64 cpuinfoTransitionTableString, err := util.ReadFileNoStat(filepath.Join(cpuPath, "stats", "trans_table")) if err != nil { if !(os.IsNotExist(err) \|\| os.IsPermission(err)) { return &SystemCPUCpufreqStats{}, err } } else { cpuinfoTransitionTable = &[][]uint64{} for i, line := range strings.Split(string(cpuinfoTransitionTableString), "\n") { // Skip the "From: To" header. if i == 0 \|\| line == "" { continue } fields := strings.Fields(line) fields[0] = strings.TrimSuffix(fields[0], ":") cpuinfoTransitionTableRow := make([]uint64, len(fields)) for i := range fields { if len(fields[i]) == 0 { continue } f, err := strconv.ParseUint(fields[i], 10, 64) if err != nil { return &SystemCPUCpufreqStats{}, err } cpuinfoTransitionTableRow[i] = f } cpuinfoTransitionTable = append(cpuinfoTransitionTable, cpuinfoTransitionTableRow) } } return &SystemCPUCpufreqStats{ CpuinfoCurrentFrequency: uintOut[0], CpuinfoMaximumFrequency: uintOut[1], CpuinfoMinimumFrequency: uintOut[2], CpuinfoTransitionLatency: uintOut[3], ScalingCurrentFrequency: uintOut[4], ScalingMaximumFrequency: uintOut[5], ScalingMinimumFrequency: uintOut[6], AvailableGovernors: stringOut[0], Driver: stringOut[1], Governor: stringOut[2], RelatedCpus: stringOut[3], SetSpeed: stringOut[4], CpuinfoFrequencyDuration: cpuinfoFrequencyDuration, CpuinfoFrequencyTransitionsTotal: cpuinfoFrequencyTransitionsTotal, CpuinfoTransitionTable: cpuinfoTransitionTable, }, nil } func (fs FS) IsolatedCPUs() ([]uint16, error) { isolcpus, err := os.ReadFile(fs.sys.Path("devices/system/cpu/isolated")) if err != nil { return nil, err } return parseCPURange(isolcpus) } func parseCPURange(data []byte) ([]uint16, error) { var cpusInt = []uint16{} for _, cpu := range strings.Split(strings.TrimSuffix(string(data), "\n"), ",") { if cpu == "" { continue } if strings.Contains(cpu, "-") { ranges := strings.Split(cpu, "-") if len(ranges) != 2 { return nil, fmt.Errorf("invalid cpu range: %s", cpu) } startRange, err := strconv.Atoi(ranges[0]) if err != nil { return nil, fmt.Errorf("invalid cpu start range: %w", err) } endRange, err := strconv.Atoi(ranges[1]) if err != nil { return nil, fmt.Errorf("invalid cpu end range: %w", err) } for i := startRange; i <= endRange; i++ { cpusInt = append(cpusInt, uint16(i)) } continue } cpuN, err := strconv.Atoi(cpu) if err != nil { return nil, err } cpusInt = append(cpusInt, uint16(cpuN)) } return cpusInt, nil }	11.89 KB	2025-05-25 12:27
📄 system_cpu_test.go // Copyright 2018 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "errors" "reflect" "testing" ) func makeUint64(v uint64) uint64 { return &v } func TestCPUTopology(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } cpus, err := fs.CPUs() if err != nil { t.Fatal(err) } if want, have := 3, len(cpus); want != have { t.Errorf("incorrect number of CPUs, have %v, want %v", want, have) } if want, have := "0", cpus[0].Number(); want != have { t.Errorf("incorrect name, have %v, want %v", want, have) } cpu0Topology, err := cpus[0].Topology() if err != nil { t.Fatal(err) } if want, have := "0", cpu0Topology.CoreID; want != have { t.Errorf("incorrect core ID, have %v, want %v", want, have) } if want, have := "0-7", cpu0Topology.CoreSiblingsList; want != have { t.Errorf("incorrect core siblings list, have %v, want %v", want, have) } cpu1Topology, err := cpus[1].Topology() if err != nil { t.Fatal(err) } if want, have := "0", cpu1Topology.PhysicalPackageID; want != have { t.Errorf("incorrect package ID, have %v, want %v", want, have) } if want, have := "1,5", cpu1Topology.ThreadSiblingsList; want != have { t.Errorf("incorrect thread siblings list, have %v, want %v", want, have) } } func TestCPUThermalThrottle(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } cpus, err := fs.CPUs() if err != nil { t.Fatal(err) } if want, have := 3, len(cpus); want != have { t.Errorf("incorrect number of CPUs, have %v, want %v", want, have) } cpu0Throttle, err := cpus[0].ThermalThrottle() if err != nil { t.Fatal(err) } if want, have := uint64(34818), cpu0Throttle.PackageThrottleCount; want != have { t.Errorf("incorrect package throttle count, have %v, want %v", want, have) } cpu1Throttle, err := cpus[1].ThermalThrottle() if err != nil { t.Fatal(err) } if want, have := uint64(523), cpu1Throttle.CoreThrottleCount; want != have { t.Errorf("incorrect core throttle count, have %v, want %v", want, have) } } func TestSystemCpufreq(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } c, err := fs.SystemCpufreq() if err != nil { t.Fatal(err) } systemCpufreq := []SystemCPUCpufreqStats{ // The following files are missing for the first CPU: // * `cpuinfo_cur_freq` // * `time_in_state` // * `total_trans` { Name: "0", CpuinfoCurrentFrequency: nil, CpuinfoMinimumFrequency: makeUint64(800000), CpuinfoMaximumFrequency: makeUint64(2400000), CpuinfoTransitionLatency: makeUint64(0), ScalingCurrentFrequency: makeUint64(1219917), ScalingMinimumFrequency: makeUint64(800000), ScalingMaximumFrequency: makeUint64(2400000), AvailableGovernors: "performance powersave", Driver: "intel_pstate", Governor: "powersave", RelatedCpus: "0", SetSpeed: "<unsupported>", CpuinfoFrequencyDuration: nil, CpuinfoFrequencyTransitionsTotal: nil, CpuinfoTransitionTable: &[][]uint64{ {0, 3600000, 3400000, 3200000, 3000000, 2800000}, {3600000, 0, 5, 0, 0, 0}, {3400000, 4, 0, 2, 0, 0}, {3200000, 0, 1, 0, 2, 0}, {3000000, 0, 0, 1, 0, 3}, {2800000, 0, 0, 0, 2, 0}, }, }, // The following files are missing for the second CPU: // * `scaling_cur_freq` // * `trans_table` { Name: "1", CpuinfoCurrentFrequency: makeUint64(1200195), CpuinfoMinimumFrequency: makeUint64(1200000), CpuinfoMaximumFrequency: makeUint64(3300000), CpuinfoTransitionLatency: makeUint64(4294967295), ScalingCurrentFrequency: nil, ScalingMinimumFrequency: makeUint64(1200000), ScalingMaximumFrequency: makeUint64(3300000), AvailableGovernors: "performance powersave", Driver: "intel_pstate", Governor: "powersave", RelatedCpus: "1", SetSpeed: "<unsupported>", CpuinfoFrequencyDuration: &map[uint64]uint64{ 3600000: 2089, 3400000: 136, 3200000: 34, 3000000: 67, 2800000: 172488, }, CpuinfoFrequencyTransitionsTotal: makeUint64(20), CpuinfoTransitionTable: nil, }, } if !reflect.DeepEqual(systemCpufreq, c) { t.Errorf("Result not correct: want %v, have %v", systemCpufreq, c) } } func TestIsolatedParsingCPU(t testing.T) { var testParams = []struct { in []byte res []uint16 err error }{ {[]byte(""), []uint16{}, nil}, {[]byte("1\n"), []uint16{1}, nil}, {[]byte("1"), []uint16{1}, nil}, {[]byte("1,2"), []uint16{1, 2}, nil}, {[]byte("1-2"), []uint16{1, 2}, nil}, {[]byte("1-3"), []uint16{1, 2, 3}, nil}, {[]byte("1,2-4"), []uint16{1, 2, 3, 4}, nil}, {[]byte("1,3-4"), []uint16{1, 3, 4}, nil}, {[]byte("1,3-4,7,20-21"), []uint16{1, 3, 4, 7, 20, 21}, nil}, {[]byte("1,"), []uint16{1}, nil}, {[]byte("1,2-"), nil, errors.New(`invalid cpu end range: strconv.Atoi: parsing "": invalid syntax`)}, {[]byte("1,-3"), nil, errors.New(`invalid cpu start range: strconv.Atoi: parsing "": invalid syntax`)}, } for _, params := range testParams { t.Run("blabla", func(t testing.T) { res, err := parseCPURange(params.in) if !reflect.DeepEqual(res, params.res) { t.Fatalf("should have %v result: got %v", params.res, res) } if err != nil && params.err != nil && err.Error() != params.err.Error() { t.Fatalf("should have '%v' error: got '%v'", params.err, err) } if (err == nil \|\| params.err == nil) && err != params.err { t.Fatalf("should have %v error: got %v", params.err, err) } }) } } func TestIsolatedCPUs(t testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } isolated, err := fs.IsolatedCPUs() expected := []uint16{1, 2, 3, 4, 5, 6, 7, 9} if !reflect.DeepEqual(isolated, expected) { t.Errorf("Result not correct: want %v, have %v", expected, isolated) } if err != nil { t.Errorf("Error not correct: want %v, have %v", nil, err) } } func TestBinSearch(t testing.T) { var testParams = []struct { elem uint16 elems []uint16 res bool }{ {3, []uint16{1, 3, 5, 7, 9}, true}, {4, []uint16{1, 3, 5, 7, 9}, false}, {2, []uint16{}, false}, } for _, param := range testParams { res := binSearch(param.elem, &param.elems) if res != param.res { t.Fatalf("Result not correct: want %v, have %v", param.res, res) } } }	6.97 KB	2025-05-25 12:27
📄 vmstat_numa.go // 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. //go:build linux // +build linux package sysfs import ( "bufio" "bytes" "fmt" "path/filepath" "regexp" "strconv" "strings" "github.com/prometheus/procfs/internal/util" ) var ( nodePattern = "devices/system/node/node[0-9]" nodeNumberRegexp = regexp.MustCompile(`.devices/system/node/node([0-9]*)`) ) type VMStat struct { NrFreePages uint64 NrZoneInactiveAnon uint64 NrZoneActiveAnon uint64 NrZoneInactiveFile uint64 NrZoneActiveFile uint64 NrZoneUnevictable uint64 NrZoneWritePending uint64 NrMlock uint64 NrPageTablePages uint64 NrKernelStack uint64 NrBounce uint64 NrZspages uint64 NrFreeCma uint64 NumaHit uint64 NumaMiss uint64 NumaForeign uint64 NumaInterleave uint64 NumaLocal uint64 NumaOther uint64 NrInactiveAnon uint64 NrActiveAnon uint64 NrInactiveFile uint64 NrActiveFile uint64 NrUnevictable uint64 NrSlabReclaimable uint64 NrSlabUnreclaimable uint64 NrIsolatedAnon uint64 NrIsolatedFile uint64 WorkingsetNodes uint64 WorkingsetRefault uint64 WorkingsetActivate uint64 WorkingsetRestore uint64 WorkingsetNodereclaim uint64 NrAnonPages uint64 NrMapped uint64 NrFilePages uint64 NrDirty uint64 NrWriteback uint64 NrWritebackTemp uint64 NrShmem uint64 NrShmemHugepages uint64 NrShmemPmdmapped uint64 NrFileHugepages uint64 NrFilePmdmapped uint64 NrAnonTransparentHugepages uint64 NrVmscanWrite uint64 NrVmscanImmediateReclaim uint64 NrDirtied uint64 NrWritten uint64 NrKernelMiscReclaimable uint64 NrFollPinAcquired uint64 NrFollPinReleased uint64 } func (fs FS) VMStatNUMA() (map[int]VMStat, error) { m := make(map[int]VMStat) nodes, err := filepath.Glob(fs.sys.Path(nodePattern)) if err != nil { return nil, err } for _, node := range nodes { nodeNumbers := nodeNumberRegexp.FindStringSubmatch(node) if len(nodeNumbers) != 2 { continue } nodeNumber, err := strconv.Atoi(nodeNumbers[1]) if err != nil { return nil, err } file, err := util.ReadFileNoStat(filepath.Join(node, "vmstat")) if err != nil { return nil, err } nodeStats, err := parseVMStatNUMA(file) if err != nil { return nil, err } m[nodeNumber] = nodeStats } return m, nil } func parseVMStatNUMA(r []byte) (VMStat, error) { var ( vmStat = VMStat{} scanner = bufio.NewScanner(bytes.NewReader(r)) ) for scanner.Scan() { line := strings.TrimSpace(scanner.Text()) if line == "" { continue } parts := strings.Fields(line) if len(parts) != 2 { return vmStat, fmt.Errorf("line scan did not return 2 fields: %s", line) } fv, err := strconv.ParseUint(parts[1], 10, 64) if err != nil { return vmStat, fmt.Errorf("invalid value in vmstat: %w", err) } switch parts[0] { case "nr_free_pages": vmStat.NrFreePages = fv case "nr_zone_inactive_anon": vmStat.NrZoneInactiveAnon = fv case "nr_zone_active_anon": vmStat.NrZoneActiveAnon = fv case "nr_zone_inactive_file": vmStat.NrZoneInactiveFile = fv case "nr_zone_active_file": vmStat.NrZoneActiveFile = fv case "nr_zone_unevictable": vmStat.NrZoneUnevictable = fv case "nr_zone_write_pending": vmStat.NrZoneWritePending = fv case "nr_mlock": vmStat.NrMlock = fv case "nr_page_table_pages": vmStat.NrPageTablePages = fv case "nr_kernel_stack": vmStat.NrKernelStack = fv case "nr_bounce": vmStat.NrBounce = fv case "nr_zspages": vmStat.NrZspages = fv case "nr_free_cma": vmStat.NrFreeCma = fv case "numa_hit": vmStat.NumaHit = fv case "numa_miss": vmStat.NumaMiss = fv case "numa_foreign": vmStat.NumaForeign = fv case "numa_interleave": vmStat.NumaInterleave = fv case "numa_local": vmStat.NumaLocal = fv case "numa_other": vmStat.NumaOther = fv case "nr_inactive_anon": vmStat.NrInactiveAnon = fv case "nr_active_anon": vmStat.NrActiveAnon = fv case "nr_inactive_file": vmStat.NrInactiveFile = fv case "nr_active_file": vmStat.NrActiveFile = fv case "nr_unevictable": vmStat.NrUnevictable = fv case "nr_slab_reclaimable": vmStat.NrSlabReclaimable = fv case "nr_slab_unreclaimable": vmStat.NrSlabUnreclaimable = fv case "nr_isolated_anon": vmStat.NrIsolatedAnon = fv case "nr_isolated_file": vmStat.NrIsolatedFile = fv case "workingset_nodes": vmStat.WorkingsetNodes = fv case "workingset_refault": vmStat.WorkingsetRefault = fv case "workingset_activate": vmStat.WorkingsetActivate = fv case "workingset_restore": vmStat.WorkingsetRestore = fv case "workingset_nodereclaim": vmStat.WorkingsetNodereclaim = fv case "nr_anon_pages": vmStat.NrAnonPages = fv case "nr_mapped": vmStat.NrMapped = fv case "nr_file_pages": vmStat.NrFilePages = fv case "nr_dirty": vmStat.NrDirty = fv case "nr_writeback": vmStat.NrWriteback = fv case "nr_writeback_temp": vmStat.NrWritebackTemp = fv case "nr_shmem": vmStat.NrShmem = fv case "nr_shmem_hugepages": vmStat.NrShmemHugepages = fv case "nr_shmem_pmdmapped": vmStat.NrShmemPmdmapped = fv case "nr_file_hugepages": vmStat.NrFileHugepages = fv case "nr_file_pmdmapped": vmStat.NrFilePmdmapped = fv case "nr_anon_transparent_hugepages": vmStat.NrAnonTransparentHugepages = fv case "nr_vmscan_write": vmStat.NrVmscanWrite = fv case "nr_vmscan_immediate_reclaim": vmStat.NrVmscanImmediateReclaim = fv case "nr_dirtied": vmStat.NrDirtied = fv case "nr_written": vmStat.NrWritten = fv case "nr_kernel_misc_reclaimable": vmStat.NrKernelMiscReclaimable = fv case "nr_foll_pin_acquired": vmStat.NrFollPinAcquired = fv case "nr_foll_pin_released": vmStat.NrFollPinReleased = fv } } return vmStat, scanner.Err() }	6.74 KB	2025-05-25 12:27
📄 vmstat_numa_test.go // 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. //go:build linux // +build linux package sysfs import ( "testing" ) func TestParseVMStatNUMA(t *testing.T) { fs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(err) } vmstat, err := fs.VMStatNUMA() if err != nil { t.Fatal(err) } if want, got := uint64(1), vmstat[1].NrFreePages; want != got { t.Errorf("want vmstat stat nr_free_pages value %d, got %d", want, got) } if want, got := uint64(5), vmstat[1].NrZoneActiveFile; want != got { t.Errorf("want numa stat nr_zone_active_file %d, got %d", want, got) } if want, got := uint64(7), vmstat[2].NrFreePages; want != got { t.Errorf("want vmstat stat nr_free_pages value %d, got %d", want, got) } if want, got := uint64(11), vmstat[2].NrZoneActiveFile; want != got { t.Errorf("want numa stat nr_zone_active_file %d, got %d", want, got) } }	1.39 KB	2025-05-25 12:27
📄 vulnerability.go // 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. //go:build linux // +build linux package sysfs import ( "os" "path/filepath" "strings" ) const ( notAffected = "not affected" // based on: https://www.kernel.org/doc/Documentation/ABI/testing/sysfs-devices-system-cpu vulnerable = "vulnerable" mitigation = "mitigation" unknown = "unknown" ) const ( VulnerabilityStateNotAffected = iota VulnerabilityStateVulnerable VulnerabilityStateMitigation VulnerabilityStateUnknown ) var ( // VulnerabilityHumanEncoding allows mapping the vulnerability state (encoded as an int) onto a human friendly // string. It can be used by consumers of this library to expose to the user the state of the vulnerability. VulnerabilityHumanEncoding = map[int]string{ VulnerabilityStateNotAffected: notAffected, VulnerabilityStateVulnerable: vulnerable, VulnerabilityStateMitigation: mitigation, VulnerabilityStateUnknown: unknown, } ) // CPUVulnerabilities retrieves a map of vulnerability names to their mitigations. func (fs FS) CPUVulnerabilities() (map[string]Vulnerability, error) { matchingFilepaths, err := filepath.Glob(fs.sys.Path("devices/system/cpu/vulnerabilities/")) if err != nil { return nil, err } vulnerabilities := make(map[string]Vulnerability, len(matchingFilepaths)) for _, path := range matchingFilepaths { filename := filepath.Base(path) rawContent, err := os.ReadFile(path) if err != nil { return nil, err } v, err := parseVulnerability(filename, string(rawContent)) if err != nil { return nil, err } vulnerabilities[filename] = v } return vulnerabilities, nil } // Vulnerability represents a single vulnerability extracted from /sys/devices/system/cpu/vulnerabilities/. type Vulnerability struct { CodeName string State int Mitigation string } func parseVulnerability(name, rawContent string) (Vulnerability, error) { v := &Vulnerability{CodeName: name} rawContent = strings.TrimSpace(rawContent) rawContentLower := strings.ToLower(rawContent) switch { case strings.HasPrefix(rawContentLower, notAffected): v.State = VulnerabilityStateNotAffected case strings.HasPrefix(rawContentLower, vulnerable): v.State = VulnerabilityStateVulnerable m := strings.Fields(rawContent) if len(m) > 1 { v.Mitigation = strings.Join(m[1:], " ") } case strings.HasPrefix(rawContentLower, mitigation): v.State = VulnerabilityStateMitigation m := strings.Fields(rawContent) if len(m) > 1 { v.Mitigation = strings.Join(m[1:], " ") } case strings.HasPrefix(rawContentLower, unknown): v.State = VulnerabilityStateUnknown m := strings.Fields(rawContent) if len(m) > 1 { v.Mitigation = strings.Join(m[1:], " ") } default: // Output the raw data obtained from the vulnerability, with state // unknown, rather than erroring out v.State = VulnerabilityStateUnknown v.Mitigation = rawContent } return v, nil }	3.39 KB	2025-05-25 12:27
📄 vulnerability_test.go // Copyright 2023 The Prometheus Authors // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. //go:build linux // +build linux package sysfs import ( "fmt" "reflect" "testing" ) func TestFS_CPUVulnerabilities(t testing.T) { sysFs, err := NewFS(sysTestFixtures) if err != nil { t.Fatal(fmt.Errorf("failed to get sysfs FS: %w", err)) } got, err := sysFs.CPUVulnerabilities() if err != nil { t.Fatal(fmt.Errorf("failed to parse sysfs vulnerabilities files: %w", err)) } tests := []struct { name string vulnerabilityName string want Vulnerability wantErr bool }{ {"Not affected", "tsx_async_abort", &Vulnerability{CodeName: "tsx_async_abort", State: VulnerabilityStateNotAffected, Mitigation: ""}, false}, {"Mitigation simple string", "spec_store_bypass", &Vulnerability{CodeName: "spec_store_bypass", State: VulnerabilityStateMitigation, Mitigation: "Speculative Store Bypass disabled via prctl"}, false}, {"Mitigation special chars", "retbleed", &Vulnerability{CodeName: "retbleed", State: VulnerabilityStateMitigation, Mitigation: "untrained return thunk; SMT enabled with STIBP protection"}, false}, {"Mitigation more special chars", "spectre_v1", &Vulnerability{CodeName: "spectre_v1", State: VulnerabilityStateMitigation, Mitigation: "usercopy/swapgs barriers and __user pointer sanitization"}, false}, {"Mitigation with multiple subsections", "spectre_v2", &Vulnerability{CodeName: "spectre_v2", State: VulnerabilityStateMitigation, Mitigation: "Retpolines, IBPB: conditional, STIBP: always-on, RSB filling, PBRSB-eIBRS: Not affected"}, false}, {"Vulnerable", "mds", &Vulnerability{CodeName: "mds", State: VulnerabilityStateVulnerable, Mitigation: ""}, false}, {"Vulnerable with mitigation available", "mmio_stale_data", &Vulnerability{CodeName: "mmio_stale_data", State: VulnerabilityStateVulnerable, Mitigation: "Clear CPU buffers attempted, no microcode"}, false}, {"Unknown", "srbds", &Vulnerability{CodeName: "srbds", State: VulnerabilityStateUnknown, Mitigation: "Dependent on hypervisor status"}, false}, {"Unknown with unparseable mitigation", "itlb_multihit", &Vulnerability{CodeName: "itlb_multihit", State: VulnerabilityStateUnknown, Mitigation: "KVM: Mitigation: VMX unsupported"}, false}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { gotVulnerability, ok := got[tt.vulnerabilityName] if !ok && !tt.wantErr { t.Errorf("CPUVulnerabilities() vulnerability %s not found", tt.vulnerabilityName) } if !reflect.DeepEqual(gotVulnerability, tt.want) { t.Errorf("CPUVulnerabilities() gotVulnerability = %v, want %v", gotVulnerability, tt.want) } }) } }	3.12 KB	2025-05-25 12:27

Edit File:

Terminal