feat: display current CPU frequency on dashboard

Dashboard now shows the active frequency of each CPU core when cpufreq
is available on non-virtualized systems, enhancing real-time accuracy.

Solves the issue of displaying 0MHz on certain SBCs due to
/proc/cpuinfo limitations.

Signed-off-by: Nico Berlee <[email protected]>
Signed-off-by: Andrey Smirnov <[email protected]>

Author: nberlee

api/machine/machine.proto

@@ -21,6 +21,7 @@ service MachineService {
   rpc Bootstrap(BootstrapRequest) returns (BootstrapResponse);
   rpc Containers(ContainersRequest) returns (ContainersResponse);
   rpc Copy(CopyRequest) returns (stream common.Data);
+  rpc CPUFreqStats(google.protobuf.Empty) returns (CPUFreqStatsResponse);
   rpc CPUInfo(google.protobuf.Empty) returns (CPUInfoResponse);
   rpc DiskStats(google.protobuf.Empty) returns (DiskStatsResponse);
   rpc Dmesg(DmesgRequest) returns (stream common.Data);
@@ -843,6 +844,24 @@ message SoftIRQStat {
   uint64 rcu = 10;
 }
 
+// rpc CPUFreqStats
+
+message CPUFreqStatsResponse {
+  repeated CPUsFreqStats messages = 1;
+}
+
+message CPUsFreqStats {
+  common.Metadata metadata = 1;
+  repeated CPUFreqStats cpu_freq_stats = 2;
+}
+
+message CPUFreqStats {
+  uint64 current_frequency = 1;
+  uint64 minimum_frequency = 2;
+  uint64 maximum_frequency = 3;
+  string governor = 4;
+}
+
 // rpc CPUInfo
 
 message CPUInfoResponse {

internal/app/machined/internal/server/v1alpha1/v1alpha1_monitoring.go

@@ -12,6 +12,7 @@ import (
 	"strings"
 
 	"github.com/prometheus/procfs"
+	"github.com/prometheus/procfs/sysfs"
 	"github.com/siderolabs/gen/maps"
 	"github.com/siderolabs/gen/xslices"
 	"google.golang.org/protobuf/types/known/emptypb"
@@ -141,6 +142,42 @@ func (s *Server) SystemStat(ctx context.Context, in *emptypb.Empty) (*machine.Sy
 	return reply, nil
 }
 
+// CPUFreqStats implements the machine.MachineServer interface.
+func (s *Server) CPUFreqStats(ctx context.Context, in *emptypb.Empty) (*machine.CPUFreqStatsResponse, error) {
+	fs, err := sysfs.NewDefaultFS()
+	if err != nil {
+		return nil, err
+	}
+
+	systemCpufreqStats, err := fs.SystemCpufreq()
+	if err != nil {
+		return nil, err
+	}
+
+	translateCPUFreqStats := func(in sysfs.SystemCPUCpufreqStats) *machine.CPUFreqStats {
+		if in.CpuinfoCurrentFrequency == nil || in.CpuinfoMinimumFrequency == nil || in.CpuinfoMaximumFrequency == nil {
+			return &machine.CPUFreqStats{}
+		}
+
+		return &machine.CPUFreqStats{
+			CurrentFrequency: *in.CpuinfoCurrentFrequency,
+			MinimumFrequency: *in.CpuinfoMinimumFrequency,
+			MaximumFrequency: *in.CpuinfoMaximumFrequency,
+			Governor:         in.Governor,
+		}
+	}
+
+	reply := &machine.CPUFreqStatsResponse{
+		Messages: []*machine.CPUsFreqStats{
+			{
+				CpuFreqStats: xslices.Map(systemCpufreqStats, translateCPUFreqStats),
+			},
+		},
+	}
+
+	return reply, nil
+}
+
 // CPUInfo implements the machine.MachineServer interface.
 func (s *Server) CPUInfo(ctx context.Context, in *emptypb.Empty) (*machine.CPUInfoResponse, error) {
 	fs, err := procfs.NewDefaultFS()

internal/app/machined/pkg/system/services/machined.go

@@ -41,6 +41,7 @@ var rules = map[string]role.Set{
 	"/machine.MachineService/ApplyConfiguration":          role.MakeSet(role.Admin),
 	"/machine.MachineService/Bootstrap":                   role.MakeSet(role.Admin),
 	"/machine.MachineService/CPUInfo":                     role.MakeSet(role.Admin, role.Operator, role.Reader),
+	"/machine.MachineService/CPUFreqStats":                role.MakeSet(role.Admin, role.Operator, role.Reader),
 	"/machine.MachineService/Containers":                  role.MakeSet(role.Admin, role.Operator, role.Reader),
 	"/machine.MachineService/Copy":                        role.MakeSet(role.Admin),
 	"/machine.MachineService/DiskStats":                   role.MakeSet(role.Admin, role.Operator, role.Reader),

internal/integration/api/monitoring.go

@@ -0,0 +1,73 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//go:build integration_api
+
+package api
+
+import (
+	"context"
+	"time"
+
+	"google.golang.org/protobuf/types/known/emptypb"
+
+	"github.com/siderolabs/talos/internal/integration/base"
+	"github.com/siderolabs/talos/pkg/machinery/client"
+)
+
+// MonitoringSuite ...
+type MonitoringSuite struct {
+	base.APISuite
+
+	ctx       context.Context //nolint:containedctx
+	ctxCancel context.CancelFunc
+}
+
+// SuiteName ...
+func (suite *MonitoringSuite) SuiteName() string {
+	return "api.MonitoringSuite"
+}
+
+// SetupTest ...
+func (suite *MonitoringSuite) SetupTest() {
+	suite.ctx, suite.ctxCancel = context.WithTimeout(context.Background(), 30*time.Second)
+}
+
+// TearDownTest ...
+func (suite *MonitoringSuite) TearDownTest() {
+	if suite.ctxCancel != nil {
+		suite.ctxCancel()
+	}
+}
+
+// TestMonitoringAPIs tests that monitoring APIs are working.
+func (suite *MonitoringSuite) TestMonitoringAPIs() {
+	node := suite.RandomDiscoveredNodeInternalIP()
+	nodeCtx := client.WithNode(suite.ctx, node)
+
+	_, err := suite.Client.MachineClient.CPUFreqStats(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.CPUInfo(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.DiskStats(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.LoadAvg(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.Memory(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.NetworkDeviceStats(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+
+	_, err = suite.Client.MachineClient.SystemStat(nodeCtx, &emptypb.Empty{})
+	suite.Require().NoError(err)
+}
+
+func init() {
+	allSuites = append(allSuites, new(MonitoringSuite))
+}

internal/pkg/dashboard/apidata/node.go

@@ -13,16 +13,17 @@ import (
 // Node represents data gathered from a single node.
 type Node struct {
 	// These fields are directly API responses.
-	Hostname    *machine.Hostname
-	LoadAvg     *machine.LoadAvg
-	Version     *machine.Version
-	Memory      *machine.Memory
-	SystemStat  *machine.SystemStat
-	CPUsInfo    *machine.CPUsInfo
-	NetDevStats *machine.NetworkDeviceStats
-	DiskStats   *machine.DiskStats
-	Processes   *machine.Process
-	ServiceList *machine.ServiceList
+	Hostname      *machine.Hostname
+	LoadAvg       *machine.LoadAvg
+	Version       *machine.Version
+	Memory        *machine.Memory
+	SystemStat    *machine.SystemStat
+	CPUsFreqStats *machine.CPUsFreqStats
+	CPUsInfo      *machine.CPUsInfo
+	NetDevStats   *machine.NetworkDeviceStats
+	DiskStats     *machine.DiskStats
+	Processes     *machine.Process
+	ServiceList   *machine.ServiceList
 
 	// These fields are calculated as diff with Node data from previous pol.
 	SystemStatDiff  *machine.SystemStat

internal/pkg/dashboard/apidata/source.go

@@ -179,6 +179,27 @@ func (source *Source) gather() *Data {
 
 			return nil
 		},
+		func() error {
+			resp, err := source.MachineClient.CPUFreqStats(source.ctx, &emptypb.Empty{})
+			if err != nil {
+				return err
+			}
+
+			resultLock.Lock()
+			defer resultLock.Unlock()
+
+			for _, msg := range resp.GetMessages() {
+				node := source.node(msg)
+
+				if _, ok := result.Nodes[node]; !ok {
+					result.Nodes[node] = &Node{}
+				}
+
+				result.Nodes[node].CPUsFreqStats = msg
+			}
+
+			return nil
+		},
 		func() error {
 			resp, err := source.MachineClient.CPUInfo(source.ctx, &emptypb.Empty{})
 			if err != nil {

internal/pkg/dashboard/components/header.go

@@ -7,6 +7,7 @@ package components
 import (
 	"fmt"
 	"math"
+	"sort"
 	"strconv"
 	"time"
 
@@ -24,7 +25,6 @@ type headerData struct {
 	hostname        string
 	version         string
 	uptime          string
-	numCPUs         string
 	cpuFreq         string
 	totalMem        string
 	numProcesses    string
@@ -107,11 +107,10 @@ func (widget *Header) redraw() {
 	data := widget.getOrCreateNodeData(widget.selectedNode)
 
 	text := fmt.Sprintf(
-		"[yellow::b]%s[-:-:-] (%s): uptime %s, %sx%s, %s RAM, PROCS %s, CPU %s, RAM %s",
+		"[yellow::b]%s[-:-:-] (%s): uptime %s, %s, %s RAM, PROCS %s, CPU %s, RAM %s",
 		data.hostname,
 		data.version,
 		data.uptime,
-		data.numCPUs,
 		data.cpuFreq,
 		data.totalMem,
 		data.numProcesses,
@@ -122,6 +121,7 @@ func (widget *Header) redraw() {
 	widget.SetText(text)
 }
 
+//nolint:gocyclo
 func (widget *Header) updateNodeAPIData(node string, data *apidata.Node) {
 	nodeData := widget.getOrCreateNodeData(node)
 
@@ -147,13 +147,46 @@ func (widget *Header) updateNodeAPIData(node string, data *apidata.Node) {
 	if data.CPUsInfo != nil {
 		numCPUs := len(data.CPUsInfo.GetCpuInfo())
 
-		nodeData.numCPUs = strconv.Itoa(numCPUs)
-
 		if numCPUs > 0 {
+			nodeData.cpuFreq = fmt.Sprintf("%dx%s", numCPUs, widget.humanizeCPUFrequency(data.CPUsInfo.GetCpuInfo()[0].GetCpuMhz()))
+		} else {
 			nodeData.cpuFreq = widget.humanizeCPUFrequency(data.CPUsInfo.GetCpuInfo()[0].GetCpuMhz())
 		}
 	}
 
+	if data.CPUsFreqStats != nil && data.CPUsFreqStats.CpuFreqStats != nil {
+		numCPUs := len(data.CPUsFreqStats.CpuFreqStats)
+		uniqMhz := make(map[uint64]int, numCPUs)
+
+		for _, cpuFreqStat := range data.CPUsFreqStats.CpuFreqStats {
+			uniqMhz[cpuFreqStat.CurrentFrequency]++
+		}
+
+		keys := make([]uint64, 0, len(uniqMhz))
+
+		for mhz := range uniqMhz {
+			if mhz == 0 {
+				continue
+			}
+
+			keys = append(keys, mhz)
+		}
+
+		if len(keys) > 0 {
+			sort.Slice(keys, func(i, j int) bool { return keys[i] > keys[j] })
+
+			nodeData.cpuFreq = ""
+		}
+
+		for i, mhz := range keys {
+			if i > 0 {
+				nodeData.cpuFreq += " "
+			}
+
+			nodeData.cpuFreq += fmt.Sprintf("%dx%s", uniqMhz[mhz], widget.humanizeCPUFrequency(float64(mhz)/1000.0))
+		}
+	}
+
 	if data.Processes != nil {
 		nodeData.numProcesses = strconv.Itoa(len(data.Processes.GetProcesses()))
 	}
@@ -170,7 +203,6 @@ func (widget *Header) getOrCreateNodeData(node string) *headerData {
 			hostname:        notAvailable,
 			version:         notAvailable,
 			uptime:          notAvailable,
-			numCPUs:         notAvailable,
 			cpuFreq:         notAvailable,
 			totalMem:        notAvailable,
 			numProcesses:    notAvailable,