Integrate T-BC on Perla2 platform

Assisted by Cursor AI
Add Perla2 vendor definitions
Integrate on the target

Signed-off-by: Vitaly Grinberg <[email protected]>

Author: vitus133

Dockerfile

@@ -5,7 +5,7 @@ RUN make clean && make
 
 FROM quay.io/centos/centos:stream9
 
-RUN yum -y update && yum -y update glibc && yum --setopt=skip_missing_names_on_install=False -y install linuxptp ethtool hwdata synce4l && yum clean all
+RUN yum -y update && yum -y update glibc && yum --setopt=skip_missing_names_on_install=False -y install pciutils linuxptp ethtool hwdata synce4l && yum clean all
 
 
 RUN yum install -y procps-ng

go.mod

@@ -11,7 +11,7 @@ require (
 	github.com/golang/glog v1.2.4
 	github.com/google/goexpect v0.0.0-20210430020637-ab937bf7fd6f
 	github.com/jaypipes/ghw v0.12.0
-	github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251105200506-7495c02a5a34
+	github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251204124210-1fe2e26893f5
 	github.com/mdlayher/genetlink v1.3.2
 	github.com/mdlayher/netlink v1.7.2
 	github.com/prometheus/client_golang v1.16.0

go.sum

@@ -94,8 +94,8 @@ github.com/josharian/native v1.1.0 h1:uuaP0hAbW7Y4l0ZRQ6C9zfb7Mg1mbFKry/xzDAfmtL
 github.com/josharian/native v1.1.0/go.mod h1:7X/raswPFr05uY3HiLlYeyQntB6OO7E/d2Cu7qoaN2w=
 github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
 github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
-github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251105200506-7495c02a5a34 h1:wgQR7ZC6EcPjUNGkmAwoT89Hff1PbitpPe8KDjl+lVM=
-github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251105200506-7495c02a5a34/go.mod h1:sZdvVrCIjLF8TF7D1Jd1C+Awv+qZ8oY1W9/lliM1p78=
+github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251204124210-1fe2e26893f5 h1:nE9BDzM+55YROTu6tYGwroNJ3yPTNmUKg1ABxZdBIdM=
+github.com/k8snetworkplumbingwg/ptp-operator v0.0.0-20251204124210-1fe2e26893f5/go.mod h1:sZdvVrCIjLF8TF7D1Jd1C+Awv+qZ8oY1W9/lliM1p78=
 github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=

pkg/controller/hardwareconfig_controller.go

@@ -17,6 +17,10 @@ import (
 	ptpv2alpha1 "github.com/k8snetworkplumbingwg/ptp-operator/api/v2alpha1"
 )
 
+const (
+	backoffTime = 15 * time.Second
+)
+
 // HardwareConfigUpdateHandler defines the interface implemented by the daemon (or a test double)
 // to receive effective hardware configuration updates computed by this controller.
 //
@@ -90,8 +94,7 @@ func (r *HardwareConfigReconciler) Reconcile(ctx context.Context, req ctrl.Reque
 			glog.Infof("HardwareConfig deleted, recalculating hardware configurations name=%s", req.Name)
 			return r.reconcileAllConfigs(ctx)
 		}
-		glog.Errorf("Failed to get HardwareConfig: %v", err)
-		return ctrl.Result{}, err
+		return ctrl.Result{}, fmt.Errorf("failed to get HardwareConfig: %w", err)
 	}
 
 	// Recalculate and apply hardware configuration for this node
@@ -147,51 +150,51 @@ func (r *HardwareConfigReconciler) reconcileAllConfigs(ctx context.Context) (ctr
 	// List all HardwareConfigs in the cluster
 	hwConfigList := &ptpv2alpha1.HardwareConfigList{}
 	if err := r.List(ctx, hwConfigList); err != nil {
-		glog.Errorf("Failed to list HardwareConfigs: %v", err)
-		return ctrl.Result{}, err
+		return ctrl.Result{}, fmt.Errorf("failed to list HardwareConfigs: %w", err)
 	}
 
 	// Validate hardware config separation before proceeding
 	if err := r.validateHardwareConfigSeparation(hwConfigList.Items); err != nil {
 		glog.Errorf("Hardware config validation failed: %v", err)
 		// Don't return error to avoid controller crash, but log the issue
-		// In production, you might want to set a status condition instead
+		// TODO: Set a status condition instead
+		//  add a status condition to the HardwareConfig CRD to enable that
+		// type HardwareConfigStatus struct {
+		// 	MatchedNodes []MatchedNode      `json:"matchedNodes,omitempty" yaml:"matchedNodes,omitempty"`
+		// 	Conditions   []metav1.Condition `json:"conditions,omitempty"
 	}
 
 	// Check if any hardware configs are associated with currently active PTP profiles
 	// If so, trigger a PTP restart to ensure hardware and PTP configurations are synchronized
 	needsPTPRestart := r.checkIfActiveProfilesAffected(ctx, hwConfigList.Items)
 
 	// Calculate the applicable hardware configurations for this node
-	applicableConfigs, err := r.calculateNodeHardwareConfigs(ctx, hwConfigList.Items)
-	if err != nil {
-		glog.Errorf("Failed to calculate node hardware configurations: %v", err)
-		return ctrl.Result{}, err
-	}
+	applicableConfigs := r.calculateNodeHardwareConfigs(ctx, hwConfigList.Items)
 
 	// Apply hardware configurations via the handler (the daemon instance in production)
 	if len(applicableConfigs) > 0 {
 		glog.Infof("Updating daemon hardware configuration with %d hardware configs for node %s", len(applicableConfigs), r.NodeName)
 
 		// Send hardware configuration update to daemon (HardwareConfigHandler)
 		if r.HardwareConfigHandler != nil {
-			err = r.HardwareConfigHandler.UpdateHardwareConfig(applicableConfigs)
+			err := r.HardwareConfigHandler.UpdateHardwareConfig(applicableConfigs)
 			if err != nil {
-				glog.Errorf("Failed to update daemon hardware configuration: %v", err)
-				return ctrl.Result{}, err
+				glog.Infof("could not update daemon hardware configuration: %v (will retry after backoff)", err)
+				// Requeue after a short delay to avoid immediate retry storms
+				return ctrl.Result{RequeueAfter: backoffTime}, nil
 			}
 		}
-
 		glog.Infof("Successfully updated daemon hardware configuration configs=%d", len(applicableConfigs))
 	} else {
 		glog.Infof("No applicable hardware configurations found for node %s", r.NodeName)
 
 		// Clear hardware configurations if needed
 		if r.HardwareConfigHandler != nil {
-			err = r.HardwareConfigHandler.UpdateHardwareConfig([]ptpv2alpha1.HardwareConfig{})
+			err := r.HardwareConfigHandler.UpdateHardwareConfig([]ptpv2alpha1.HardwareConfig{})
 			if err != nil {
-				glog.Errorf("Failed to clear daemon hardware configuration: %v", err)
-				return ctrl.Result{}, err
+				glog.Errorf("Failed to clear daemon hardware configuration: %v (will retry after backoff)", err)
+				// Requeue after a short delay to avoid immediate retry storms
+				return ctrl.Result{RequeueAfter: backoffTime}, nil
 			}
 		}
 	}
@@ -243,24 +246,21 @@ func (r *HardwareConfigReconciler) scheduleDeferredRestart(_ context.Context) {
 }
 
 // calculateNodeHardwareConfigs determines which hardware configurations should be applied to this node
-//
-//nolint:unparam // error return is kept for future node matching logic
-func (r *HardwareConfigReconciler) calculateNodeHardwareConfigs(_ context.Context, hwConfigs []ptpv2alpha1.HardwareConfig) ([]ptpv2alpha1.HardwareConfig, error) {
+func (r *HardwareConfigReconciler) calculateNodeHardwareConfigs(_ context.Context, hwConfigs []ptpv2alpha1.HardwareConfig) []ptpv2alpha1.HardwareConfig {
 	var applicableConfigs []ptpv2alpha1.HardwareConfig
 
 	// For now, we apply all hardware configurations to all nodes
 	// This can be enhanced later with node matching logic similar to PtpConfig
 	for _, hwConfig := range hwConfigs {
-		glog.Infof("Processing HardwareConfig name=%s profile=%s", hwConfig.Name, getProfileName(hwConfig.Spec.Profile))
+		glog.Infof("Processing HardwareConfig name=%s profile=%s", hwConfig.Name, hwConfig.Spec.Profile.Name)
 
 		// TODO: Add node-specific filtering logic here
 		// For now, we include all hardware configs
 		applicableConfigs = append(applicableConfigs, hwConfig)
-		glog.Infof("Added hardware config profileName=%s relatedPtpProfile=%s", getProfileName(hwConfig.Spec.Profile), hwConfig.Spec.RelatedPtpProfileName)
+		glog.Infof("Added hardware config profileName=%s relatedPtpProfile=%s", hwConfig.Spec.Profile.Name, hwConfig.Spec.RelatedPtpProfileName)
 	}
-
 	glog.Infof("Calculated hardware configurations for node node=%s totalConfigs=%d", r.NodeName, len(applicableConfigs))
-	return applicableConfigs, nil
+	return applicableConfigs
 }
 
 // checkIfActiveProfilesAffected determines if hardware config changes should trigger PTP restart
@@ -304,14 +304,6 @@ func (r *HardwareConfigReconciler) checkIfActiveProfilesAffected(_ context.Conte
 	return false
 }
 
-// getProfileName safely extracts the profile name from a HardwareProfile
-func getProfileName(profile ptpv2alpha1.HardwareProfile) string {
-	if profile.Name != nil {
-		return *profile.Name
-	}
-	return "unnamed"
-}
-
 // SetupWithManager sets up the controller with the Manager
 func (r *HardwareConfigReconciler) SetupWithManager(mgr ctrl.Manager) error {
 	// Watch HardwareConfig resources

pkg/controller/hardwareconfig_controller_test.go

@@ -149,10 +149,7 @@ func TestCalculateNodeHardwareConfigs(t *testing.T) {
 			}
 
 			// Call the method under test
-			result, err := reconciler.calculateNodeHardwareConfigs(context.TODO(), tc.hwConfigs)
-
-			// Verify no error occurred
-			assert.NoError(t, err)
+			result := reconciler.calculateNodeHardwareConfigs(context.TODO(), tc.hwConfigs)
 
 			// Verify the number of hardware configs
 			assert.Len(t, result, tc.expectedConfigsCount,
@@ -161,11 +158,7 @@ func TestCalculateNodeHardwareConfigs(t *testing.T) {
 			// Verify config names match expected (based on profile names within configs)
 			var actualConfigNames []string
 			for _, hwConfig := range result {
-				if hwConfig.Spec.Profile.Name != nil {
-					actualConfigNames = append(actualConfigNames, *hwConfig.Spec.Profile.Name)
-				} else {
-					actualConfigNames = append(actualConfigNames, "unnamed")
-				}
+				actualConfigNames = append(actualConfigNames, *hwConfig.Spec.Profile.Name)
 			}
 			assert.ElementsMatch(t, tc.expectedConfigNames, actualConfigNames,
 				"Expected config names %v, got %v", tc.expectedConfigNames, actualConfigNames)

pkg/controller/ptpconfig_controller.go

@@ -200,6 +200,7 @@ func anyRuleMatchesNode(matchRules []ptpv1.MatchRule, nodeName string, nodeLabel
 			// TODO: Add support for "key=value" format matching
 		}
 	}
+
 	return false
 }
 

pkg/daemon/config.go

@@ -159,8 +159,7 @@ func NewLinuxPTPConfUpdate() (*LinuxPTPConfUpdate, error) {
 	if err != nil {
 		return nil, fmt.Errorf("failed to read %s: %v", PTP4L_CONF_FILE_PATH, err)
 	}
-
-	return &LinuxPTPConfUpdate{UpdateCh: make(chan bool), defaultPTP4lConfig: defaultPTP4lConfig}, nil
+	return &LinuxPTPConfUpdate{UpdateCh: make(chan bool, 10), defaultPTP4lConfig: defaultPTP4lConfig}, nil
 }
 
 func (l *LinuxPTPConfUpdate) UpdateConfig(nodeProfilesJson []byte) error {

pkg/daemon/daemon.go

@@ -25,6 +25,7 @@ import (
 	"github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/config"
 
 	"github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/dpll"
+	dpllnl "github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/dpll-netlink"
 	"github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/leap"
 
 	"github.com/k8snetworkplumbingwg/linuxptp-daemon/pkg/event"
@@ -336,6 +337,57 @@ func (dn *Daemon) getHoldoverParameters(profileName string, clockID uint64) *ptp
 	return dn.hardwareConfigManager.GetHoldoverParameters(profileName, clockID)
 }
 
+// getInterfacesFromHardwareConfig derives interfaces from hardwareconfig structure for T-BC mode.
+// It extracts the first interface from structure[*]->dpll->networkInterface.
+// Returns an empty slice if no hardwareconfig is available or no interfaces are found.
+func (dn *Daemon) getInterfacesFromHardwareConfig(nodeProfile *ptpv1.PtpProfile) config.IFaces {
+	if dn.hardwareConfigManager == nil || nodeProfile == nil || nodeProfile.Name == nil {
+		return config.IFaces{}
+	}
+
+	// Get hardware configs for this profile
+	hwProfiles := dn.hardwareConfigManager.GetHardwareConfigsForProfile(nodeProfile)
+	if len(hwProfiles) == 0 {
+		glog.V(2).Infof("No hardware configs found for profile %s", *nodeProfile.Name)
+		return config.IFaces{}
+	}
+
+	var interfaces config.IFaces
+
+	// Iterate through hardware profiles and extract interfaces from structure
+	for _, hwProfile := range hwProfiles {
+		if hwProfile.ClockChain == nil || len(hwProfile.ClockChain.Structure) == 0 {
+			continue
+		}
+
+		// Get the first subsystem from structure and use GetSubsystemNetworkInterface
+		firstSubsystem := hwProfile.ClockChain.Structure[0]
+		networkInterface, err := hardwareconfig.GetSubsystemNetworkInterface(hwProfile.ClockChain, firstSubsystem.Name)
+		if err != nil {
+			glog.V(2).Infof("Failed to get network interface for first subsystem %s: %v", firstSubsystem.Name, err)
+			continue
+		}
+
+		if networkInterface != "" {
+			// Determine event source based on T-BC configuration
+			// For T-BC, the interface typically depends on PTP4l
+			eventSource := event.PTP4l
+
+			// Get PHC ID for the interface
+			phcID := ptpnetwork.GetPhcId(networkInterface)
+
+			interfaces = append(interfaces, config.Iface{
+				Name:     networkInterface,
+				Source:   eventSource,
+				PhcId:    phcID,
+				IsMaster: false,
+			})
+		}
+	}
+
+	return interfaces
+}
+
 // New LinuxPTP is called by daemon to generate new linuxptp instance
 func New(
 	nodeName string,
@@ -450,6 +502,7 @@ func (dn *Daemon) applyNodePTPProfiles() error {
 	dn.readyTracker.setConfig(false)
 
 	glog.Infof("in applyNodePTPProfiles - starting to apply %d node profiles", len(dn.ptpUpdate.NodeProfiles))
+
 	dn.stopAllProcesses()
 	// All process should have been stopped,
 	// clear process in process manager.
@@ -485,6 +538,20 @@ func (dn *Daemon) applyNodePTPProfiles() error {
 	})
 
 	relations := reconcileRelatedProfiles(dn.ptpUpdate.NodeProfiles)
+
+	// Update PtpConfig in hardware config manager for clock chain resolution
+	// This is done after sorting and reconciliation to ensure we use the same
+	// processed profiles that will actually be applied. The NodeProfiles are already
+	// filtered to be relevant for this node by calculateNodeProfiles in the controller.
+	if dn.hardwareConfigManager != nil && len(dn.ptpUpdate.NodeProfiles) > 0 {
+		ptpConfig := &ptpv1.PtpConfig{
+			Spec: ptpv1.PtpConfigSpec{
+				Profile: dn.ptpUpdate.NodeProfiles,
+			},
+		}
+		dn.hardwareConfigManager.SetPtpConfig(ptpConfig)
+		glog.Infof("Updated PtpConfig in hardware config manager with %d profiles (after sorting and reconciliation)", len(dn.ptpUpdate.NodeProfiles))
+	}
 	// TODO: resolve clock IDs, clockType, leadingInterface and upstreamPort from hardware config
 	// (needed to keep code compatibility elsewhere and allow it to work both with hardware config and plugins)
 	for _, profile := range dn.ptpUpdate.NodeProfiles {
@@ -920,7 +987,24 @@ func (dn *Daemon) applyNodePtpProfile(runID int, nodeProfile *ptpv1.PtpProfile)
 			}
 			var clockId uint64
 			phaseOffsetPinFilter := map[string]string{}
-			for _, iface := range dprocess.ifaces {
+
+			// For T-BC mode with hardwareconfig, derive interfaces from hardwareconfig structure
+			// instead of analyzing ts2phc configuration file
+			var interfacesToUse config.IFaces
+			if profileClockType == TBC && dn.hardwareConfigManager != nil &&
+				dn.hardwareConfigManager.ReadyHardwareConfigForProfile(*nodeProfile.Name) {
+				interfacesToUse = dn.getInterfacesFromHardwareConfig(nodeProfile)
+				if len(interfacesToUse) > 0 {
+					glog.Infof("Using interfaces from hardwareconfig for T-BC profile %s: %v", *nodeProfile.Name, interfacesToUse)
+				} else {
+					glog.Warningf("Failed to derive interfaces from hardwareconfig for T-BC profile %s, falling back to ts2phc config", *nodeProfile.Name)
+					interfacesToUse = dprocess.ifaces
+				}
+			} else {
+				interfacesToUse = dprocess.ifaces
+			}
+
+			for _, iface := range interfacesToUse {
 				var eventSource []event.EventSource
 				if iface.Source == event.GNSS || iface.Source == event.PPS ||
 					(iface.Source == event.PTP4l && profileClockType == TBC) {
@@ -986,6 +1070,12 @@ func (dn *Daemon) applyNodePtpProfile(runID int, nodeProfile *ptpv1.PtpProfile)
 						// Used only in T-BC in-sync condition:
 						inSyncConditionTh, inSyncConditionTimes)
 					glog.Infof("depending on %s", dpllDaemon.DependsOn())
+					// Set hardwareconfig handler if hardwareconfig manager is available
+					if dn.hardwareConfigManager != nil {
+						dpllDaemon.SetHardwareConfigHandler(func(devices []*dpllnl.DoDeviceGetReply) error {
+							return dn.hardwareConfigManager.ProcessDPLLDeviceNotifications(devices)
+						})
+					}
 					dpllDaemon.CmdInit()
 					dprocess.depProcess = append(dprocess.depProcess, dpllDaemon)
 				}
@@ -1097,14 +1187,29 @@ func (p *ptpProcess) tBCTransitionCheck(output string, pm *plugin.PluginManager)
 }
 
 // applyConditionOrFallback applies hardware config for a condition or falls back to plugin
-func (p *ptpProcess) applyConditionOrFallback(conditionType, pluginAction string, pm *plugin.PluginManager) {
+func (p *ptpProcess) applyConditionOrFallback(conditionType, pluginAction string, pm *plugin.PluginManager, logLine string) {
 	if p.dn != nil && p.dn.hardwareConfigManager != nil {
-		if err := p.dn.hardwareConfigManager.ApplyConditionForProfile(&p.nodeProfile, conditionType); err != nil {
-			glog.Errorf("Failed to apply hardware config for '%s' condition: %v", conditionType, err)
+		// Extract source name from log line if available
+		sourceName := ""
+		if p.tbcStateDetector != nil && logLine != "" {
+			portName := p.tbcStateDetector.ExtractPortName(logLine)
+			if portName != "" {
+				// Look up source name(s) for this port
+				sources := p.tbcStateDetector.GetSourcesForPort(portName)
+				if len(sources) > 0 {
+					// Use the first matching source (typically there's only one)
+					sourceName = sources[0]
+					glog.Infof("Found source '%s' for port '%s'", sourceName, portName)
+				}
+			}
+		}
+
+		if err := p.dn.hardwareConfigManager.ApplyConditionForProfile(&p.nodeProfile, conditionType, sourceName); err != nil {
+			glog.Errorf("Failed to apply hardware config for '%s' condition (source=%s): %v", conditionType, sourceName, err)
 			// Fallback to plugin if hardware config fails
 			pm.AfterRunPTPCommand(&p.nodeProfile, pluginAction)
 		} else {
-			glog.Infof("Successfully applied hardware config for '%s' condition", conditionType)
+			glog.Infof("Successfully applied hardware config for '%s' condition (source=%s)", conditionType, sourceName)
 		}
 	} else {
 		// Fallback to plugin if no hardware config manager
@@ -1119,11 +1224,11 @@ func (p *ptpProcess) processTBCTransitionHardwareConfig(output string, pm *plugi
 
 	switch conditionType {
 	case hardwareconfig.ConditionTypeLocked:
-		p.applyConditionOrFallback(hardwareconfig.ConditionTypeLocked, "tbc-ho-exit", pm)
+		p.applyConditionOrFallback(hardwareconfig.ConditionTypeLocked, "tbc-ho-exit", pm, output)
 		p.lastTransitionResult = event.PTP_LOCKED
 		p.sendPtp4lEvent()
 	case hardwareconfig.ConditionTypeLost:
-		p.applyConditionOrFallback(hardwareconfig.ConditionTypeLost, "tbc-ho-entry", pm)
+		p.applyConditionOrFallback(hardwareconfig.ConditionTypeLost, "tbc-ho-entry", pm, output)
 		p.lastTransitionResult = event.PTP_FREERUN
 		p.sendPtp4lEvent()
 	}