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

addons/intel/clock-chain.go

@@ -249,11 +249,6 @@ func InitClockChain(opts PhaseInputsProvider, nodeProfile *ptpv1.PtpProfile) (*C
 		if err != nil {
 			return chain, fmt.Errorf("failed to initialize pins for T-BC operation: %s", err.Error())
 		}
-		glog.Info("about to enter TBC Normal mode")
-		err = chain.EnterNormalTBC()
-		if err != nil {
-			return chain, fmt.Errorf("failed to enter T-BC normal mode: %s", err.Error())
-		}
 	}
 	return chain, err
 }
@@ -420,7 +415,7 @@ func (c *ClockChain) InitPinsTBC() error {
 	// (To synchronize the DPLL1 to the E810 PHC synced by ptp4l):
 	err := c.EnableE810Outputs()
 	if err != nil {
-		glog.Error("failed to enable E810 outputs: ", err)
+		return fmt.Errorf("failed to enable E810 outputs: %w", err)
 	}
 	// Disable GNSS-1PPS (all cards), SDP20 and SDP21
 	commandsGnss, err := c.SetPinsControlForAllNICs([]PinControl{

addons/intel/intel_test.go

@@ -168,13 +168,33 @@ func Test_ProcessProfileTGMNew(t *testing.T) {
 // Test that the profile with no phase inputs is processed correctly
 func Test_ProcessProfileTBCNoPhaseInputs(t *testing.T) {
 	unitTest = true
-	mockPinSet, restorePinSet := setupBatchPinSetMock()
-	defer restorePinSet()
+
+	// Setup filesystem mock for TBC profile - EnableE810Outputs needs this
+	mockFS := &MockFileSystem{}
+	phcEntries := []os.DirEntry{MockDirEntry{name: "ptp0", isDir: true}}
+
+	// EnableE810Outputs reads the ptp directory and writes to SMA2 and period
+	mockFS.ExpectReadDir("/sys/class/net/ens4f0/device/ptp/", phcEntries, nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/pins/SMA2", []byte("2 2"), os.FileMode(0666), nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/period", []byte("2 0 0 1 0"), os.FileMode(0666), nil)
+
+	// Replace global filesystem with mock
+	originalFS := filesystem
+	filesystem = mockFS
+	defer func() { filesystem = originalFS }()
+
 	profile, err := loadProfile("./testdata/profile-tbc-no-input-delays.yaml")
 	assert.NoError(t, err)
 	err = OnPTPConfigChangeE810(nil, profile)
 	assert.NoError(t, err)
-	assert.NotNil(t, mockPinSet.commands, "Ensure clockChain.SetPinDefaults was called")
+
+	// Verify that clockChain was initialized (SetPinDefaults is called as part of InitClockChain)
+	// If SetPinDefaults wasn't called, InitClockChain would have failed
+	assert.NotNil(t, clockChain, "clockChain should be initialized")
+	assert.Equal(t, ClockTypeTBC, clockChain.Type, "clockChain should be T-BC type")
+
+	// Verify all expected filesystem calls were made
+	mockFS.VerifyAllCalls(t)
 }
 
 func Test_ProcessProfileTbc(t *testing.T) {
@@ -184,6 +204,11 @@ func Test_ProcessProfileTbc(t *testing.T) {
 	mockFS := &MockFileSystem{}
 	phcEntries := []os.DirEntry{MockDirEntry{name: "ptp0", isDir: true}}
 
+	// EnableE810Outputs is called for the leading NIC (ens4f0) - needs specific paths
+	mockFS.ExpectReadDir("/sys/class/net/ens4f0/device/ptp/", phcEntries, nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/pins/SMA2", []byte("2 2"), os.FileMode(0666), nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/period", []byte("2 0 0 1 0"), os.FileMode(0666), nil)
+
 	// profile-tbc.yaml has pins for ens4f0, ens5f0, ens8f0 (3 devices)
 	for i := 0; i < 3; i++ {
 		// Each device needs ReadDir + 4 pin writes (SMA1, SMA2, U.FL1, U.FL2)
@@ -193,7 +218,7 @@ func Test_ProcessProfileTbc(t *testing.T) {
 		}
 	}
 
-	// Add extra operations for EnableE810Outputs and other calls
+	// Add extra operations for other calls
 	for i := 0; i < 10; i++ {
 		mockFS.ExpectReadDir("", phcEntries, nil)                      // Extra ReadDir calls
 		mockFS.ExpectWriteFile("", []byte(""), os.FileMode(0666), nil) // Extra WriteFile calls
@@ -248,13 +273,18 @@ func Test_ProcessProfileTtsc(t *testing.T) {
 	mockFS := &MockFileSystem{}
 	phcEntries := []os.DirEntry{MockDirEntry{name: "ptp0", isDir: true}}
 
+	// EnableE810Outputs is called for the leading NIC (ens4f0) - needs specific paths
+	mockFS.ExpectReadDir("/sys/class/net/ens4f0/device/ptp/", phcEntries, nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/pins/SMA2", []byte("2 2"), os.FileMode(0666), nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/period", []byte("2 0 0 1 0"), os.FileMode(0666), nil)
+
 	// profile-t-tsc.yaml has pins for ens4f0 only
 	mockFS.ExpectReadDir("", phcEntries, nil) // One ReadDir
 	for i := 0; i < 4; i++ {                  // 4 pin writes
 		mockFS.ExpectWriteFile("", []byte(""), os.FileMode(0666), nil)
 	}
 
-	// Add extra operations for EnableE810Outputs and other calls
+	// Add extra operations for other calls
 	for i := 0; i < 10; i++ {
 		mockFS.ExpectReadDir("", phcEntries, nil)                      // Extra ReadDir calls
 		mockFS.ExpectWriteFile("", []byte(""), os.FileMode(0666), nil) // Extra WriteFile calls
@@ -311,6 +341,18 @@ func Test_SetPinDefaults_AllNICs(t *testing.T) {
 	defer restorePinSet()
 	unitTest = true
 
+	// Setup filesystem mock for EnableE810Outputs
+	mockFS := &MockFileSystem{}
+	phcEntries := []os.DirEntry{MockDirEntry{name: "ptp0", isDir: true}}
+	mockFS.ExpectReadDir("/sys/class/net/ens4f0/device/ptp/", phcEntries, nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/pins/SMA2", []byte("2 2"), os.FileMode(0666), nil)
+	mockFS.ExpectWriteFile("/sys/class/net/ens4f0/device/ptp/ptp0/period", []byte("2 0 0 1 0"), os.FileMode(0666), nil)
+
+	// Replace global filesystem with mock
+	originalFS := filesystem
+	filesystem = mockFS
+	defer func() { filesystem = originalFS }()
+
 	// Load a profile with multiple NICs (leading + other NICs)
 	profile, err := loadProfile("./testdata/profile-tbc.yaml")
 	assert.NoError(t, err)

go.mod

@@ -12,7 +12,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

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

pkg/daemon/config.go

@@ -162,8 +162,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
 }
 
 // UpdateConfig updates the PTP configuration from the provided JSON.