Install BFB when requested

Signed-off-by: Alexander Maslennikov <[email protected]>

Author: almaslennikov

cmd/nic-configuration-daemon/main.go

@@ -119,7 +119,7 @@ func main() {
 
 	configurationManager := configuration.NewConfigurationManager(eventRecorder, dmsManager)
 	maintenanceManager := maintenance.New(mgr.GetClient(), hostUtils, nodeName, namespace)
-	firmwareManager := firmware.NewFirmwareManager(mgr.GetClient(), namespace)
+	firmwareManager := firmware.NewFirmwareManager(mgr.GetClient(), dmsManager, namespace)
 
 	if err := initNicFwMap(namespace); err != nil {
 		log.Log.Error(err, "unable to init NicFwMap")

internal/controller/nicdevice_controller.go

@@ -47,6 +47,7 @@ import (
 	"github.com/Mellanox/nic-configuration-operator/pkg/host"
 	"github.com/Mellanox/nic-configuration-operator/pkg/maintenance"
 	"github.com/Mellanox/nic-configuration-operator/pkg/types"
+	"github.com/Mellanox/nic-configuration-operator/pkg/utils"
 )
 
 const nicDeviceSyncEventName = "nic-device-sync-event-name"
@@ -631,6 +632,12 @@ func (r *NicDeviceReconciler) handleFirmwareUpdate(ctx context.Context, status *
 		return err
 	}
 
+	if utils.IsBlueFieldDevice(status.device.Status.Type) {
+		log.Log.Info("BlueField BFB installed, reboot is required to apply changes", "device", status.device.Name)
+		status.rebootRequired = true
+		return nil
+	}
+
 	log.Log.Info("New firmware image was successfully burned. Firmware reset is required to apply changes", "device", status.device.Name)
 
 	err = r.ConfigurationManager.ResetNicFirmware(ctx, status.device)

pkg/consts/consts.go

@@ -16,7 +16,9 @@ limitations under the License.
 package consts
 
 const (
-	MellanoxVendor = "15b3"
+	MellanoxVendor     = "15b3"
+	BlueField3DeviceID = "a2dc"
+	BlueField2DeviceID = "a2d6"
 
 	Ethernet   = "Ethernet"
 	Infiniband = "Infiniband"

pkg/dms/client.go

@@ -16,6 +16,7 @@ limitations under the License.
 package dms
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"strings"
@@ -27,6 +28,7 @@ import (
 
 	"github.com/Mellanox/nic-configuration-operator/api/v1alpha1"
 	"github.com/Mellanox/nic-configuration-operator/pkg/consts"
+	"github.com/Mellanox/nic-configuration-operator/pkg/utils"
 )
 
 const (
@@ -47,6 +49,8 @@ type DMSClient interface {
 	GetQoSSettings(interfaceName string) (string, string, error)
 	// SetQoSSettings sets the QoS settings for the device (trust mode and PFC configuration). Settings are applied to all ports of the device.
 	SetQoSSettings(trustMode, pfc string) error
+	// InstallBFB installs the BFB file with the new firmware version on a BlueField device
+	InstallBFB(ctx context.Context, version string, bfbPath string) error
 }
 
 // dmsInstance implements the DMSClient interface
@@ -248,3 +252,45 @@ func (i *dmsInstance) SetQoSSettings(trust, pfc string) error {
 	log.Log.V(2).Info("QoS settings applied to all ports", "device", i.device.SerialNumber, "portCount", portCount)
 	return nil
 }
+
+// InstallBFB installs the BFB file with the new firmware version on a BlueField device
+func (i *dmsInstance) InstallBFB(ctx context.Context, version string, bfbPath string) error {
+	log.Log.V(2).Info("dmsInstance.InstallBFB()", "version", version, "bfbPath", bfbPath, "device", i.device.SerialNumber)
+
+	if !i.running.Load() {
+		log.Log.V(2).Info("DMS instance not running", "device", i.device.SerialNumber)
+		return fmt.Errorf("DMS instance is not running")
+	}
+
+	if !utils.IsBlueFieldDevice(i.device.Type) {
+		err := fmt.Errorf("cannot install BFB file on non-BlueField device")
+		log.Log.Error(err, "failed to install BFB", "device", i.device.SerialNumber, "deviceType", i.device.Type)
+		return err
+	}
+
+	args := []string{dmsClientPath, "-a", i.bindAddress, "--insecure", "os", "install", "--version", version, "--pkg", bfbPath}
+	log.Log.V(2).Info("dmsInstance.InstallBFB() install command", "args", strings.Join(args, " "))
+
+	command := i.execInterface.CommandContext(ctx, args[0], args[1:]...)
+	output, err := utils.RunCommand(command)
+	if err != nil {
+		log.Log.Error(err, "failed to install BFB", "device", i.device.SerialNumber, "deviceType", i.device.Type)
+		return err
+	}
+
+	log.Log.V(2).Info("BFB installed successfully", "device", i.device.SerialNumber, "version", version, "output", string(output))
+
+	args = []string{dmsClientPath, "-a", i.bindAddress, "--insecure", "os", "activate", "--version", version}
+	log.Log.V(2).Info("dmsInstance.InstallBFB() activate command", "args", strings.Join(args, " "))
+
+	command = i.execInterface.CommandContext(ctx, args[0], args[1:]...)
+	output, err = utils.RunCommand(command)
+	if err != nil {
+		log.Log.Error(err, "failed to activate BFB", "device", i.device.SerialNumber, "deviceType", i.device.Type)
+		return err
+	}
+
+	log.Log.V(2).Info("BFB activated successfully", "device", i.device.SerialNumber, "version", version, "output", string(output))
+
+	return nil
+}

pkg/dms/client_test.go

@@ -16,6 +16,7 @@ limitations under the License.
 package dms
 
 import (
+	"context"
 	"errors"
 	"strings"
 
@@ -239,4 +240,117 @@ var _ = Describe("DMSClient", func() {
 			})
 		})
 	})
+
+	Describe("InstallBFB", func() {
+		const (
+			testBFBVersion = "24.35.1000"
+			testBFBPath    = "/path/to/firmware.bfb"
+		)
+
+		Context("when the instance is running", func() {
+			Context("on BlueField device", func() {
+				BeforeEach(func() {
+					device.Type = "a2d6" // BlueField2 device ID
+					instance.device = device
+					instance.running.Store(true)
+				})
+
+				It("should install and activate BFB successfully", func() {
+					fakeInstallCmd := createFakeCmd([]byte("BFB install successful"), nil)
+					fakeActivateCmd := createFakeCmd([]byte("BFB activate successful"), nil)
+
+					callCount := 0
+					cmdAction := func(cmd string, args ...string) exec.Cmd {
+						callCount++
+						Expect(cmd).To(Equal(dmsClientPath))
+
+						if callCount == 1 {
+							// First call should be install command
+							Expect(args).To(ContainElement("--insecure"))
+							Expect(args).To(ContainElement("os"))
+							Expect(args).To(ContainElement("install"))
+							Expect(args).To(ContainElement("--version"))
+							Expect(args).To(ContainElement(testBFBVersion))
+							Expect(args).To(ContainElement("--pkg"))
+							Expect(args).To(ContainElement(testBFBPath))
+							return fakeInstallCmd
+						} else {
+							// Second call should be activate command
+							Expect(args).To(ContainElement("--insecure"))
+							Expect(args).To(ContainElement("os"))
+							Expect(args).To(ContainElement("activate"))
+							Expect(args).To(ContainElement("--version"))
+							Expect(args).To(ContainElement(testBFBVersion))
+							return fakeActivateCmd
+						}
+					}
+
+					fakeExec.CommandScript = []execTesting.FakeCommandAction{cmdAction, cmdAction}
+
+					err := instance.InstallBFB(context.Background(), testBFBVersion, testBFBPath)
+					Expect(err).NotTo(HaveOccurred())
+				})
+
+				It("should return error when install command fails", func() {
+					fakeInstallCmd := createFakeCmd(nil, errors.New("install failed"))
+
+					cmdAction := func(cmd string, args ...string) exec.Cmd {
+						return fakeInstallCmd
+					}
+
+					fakeExec.CommandScript = []execTesting.FakeCommandAction{cmdAction}
+
+					err := instance.InstallBFB(context.Background(), testBFBVersion, testBFBPath)
+					Expect(err).To(HaveOccurred())
+					Expect(err.Error()).To(ContainSubstring("install failed"))
+				})
+
+				It("should return error when activate command fails", func() {
+					fakeInstallCmd := createFakeCmd([]byte("BFB install successful"), nil)
+					fakeActivateCmd := createFakeCmd(nil, errors.New("activate failed"))
+
+					cmdAction := func(cmd string, args ...string) exec.Cmd {
+						if len(args) >= 3 && args[2] == "install" {
+							return fakeInstallCmd
+						}
+						return fakeActivateCmd
+					}
+
+					fakeExec.CommandScript = []execTesting.FakeCommandAction{cmdAction, cmdAction}
+
+					err := instance.InstallBFB(context.Background(), testBFBVersion, testBFBPath)
+					Expect(err).To(HaveOccurred())
+					Expect(err.Error()).To(ContainSubstring("activate failed"))
+				})
+			})
+
+			Context("on non-BlueField device", func() {
+				BeforeEach(func() {
+					device.Type = "cx6"
+					instance.device = device
+					instance.running.Store(true)
+				})
+
+				It("should return error for non-BlueField device", func() {
+					err := instance.InstallBFB(context.Background(), testBFBVersion, testBFBPath)
+					Expect(err).To(HaveOccurred())
+					Expect(err.Error()).To(ContainSubstring("cannot install BFB file on non-BlueField device"))
+				})
+			})
+		})
+
+		Context("when the instance is not running", func() {
+			BeforeEach(func() {
+				device.Type = "a2d6" // BlueField2 device ID
+				instance.device = device
+				instance.running.Store(false)
+			})
+
+			It("should return error", func() {
+				err := instance.InstallBFB(context.Background(), testBFBVersion, testBFBPath)
+				Expect(err).To(HaveOccurred())
+				Expect(err.Error()).To(Equal("DMS instance is not running"))
+			})
+		})
+	})
 })

pkg/dms/mocks/DMSClient.go

@@ -31,7 +31,9 @@ import (
 
 	"github.com/Mellanox/nic-configuration-operator/api/v1alpha1"
 	"github.com/Mellanox/nic-configuration-operator/pkg/consts"
+	"github.com/Mellanox/nic-configuration-operator/pkg/dms"
 	"github.com/Mellanox/nic-configuration-operator/pkg/types"
+	utilsPkg "github.com/Mellanox/nic-configuration-operator/pkg/utils"
 )
 
 // FirmwareManager contains logic for managing NIC devices FW on the host
@@ -53,6 +55,8 @@ type FirmwareManager interface {
 type firmwareManager struct {
 	client client.Client
 
+	dmsManager dms.DMSManager
+
 	utils FirmwareUtils
 
 	cacheRootDir string
@@ -88,9 +92,19 @@ func (f firmwareManager) ValidateRequestedFirmwareSource(ctx context.Context, de
 	case consts.FirmwareSourceDownloadFailedStatus, consts.FirmwareSourceProcessingFailedStatus, consts.FirmwareSourceCacheVerificationFailedStatus:
 		return "", fmt.Errorf("requested firmware source %s failed: %s, %s", fwSourceName, status, fwSourceObj.Status.Reason)
 	case consts.FirmwareSourceSuccessStatus:
+		deviceID := device.Status.Type
+		if utilsPkg.IsBlueFieldDevice(deviceID) {
+			version, found := fwSourceObj.Status.BFBVersions[deviceID]
+			if !found {
+				return "", fmt.Errorf("requested firmware source (%s) has no image for this BlueField device (%s)", fwSourceName, deviceID)
+			}
+
+			return version, nil
+		}
+
 		devicePSID := device.Status.PSID
 
-		for version, PSIDs := range fwSourceObj.Status.Versions {
+		for version, PSIDs := range fwSourceObj.Status.BinaryVersions {
 			if slices.Contains(PSIDs, devicePSID) {
 				return version, nil
 			}
@@ -112,8 +126,61 @@ func (f firmwareManager) BurnNicFirmware(ctx context.Context, device *v1alpha1.N
 	}
 
 	fwSourceName := device.Spec.Firmware.NicFirmwareSourceRef
-
 	cacheDir := path.Join(f.cacheRootDir, fwSourceName)
+
+	if utilsPkg.IsBlueFieldDevice(device.Status.Type) {
+		return f.burnBlueFieldFirmware(ctx, device, version, cacheDir)
+	}
+
+	return f.burnDefaultFirmware(ctx, device, version, cacheDir)
+}
+
+// burnBlueFieldFirmware handles firmware updates for BlueField devices using BFB files
+func (f firmwareManager) burnBlueFieldFirmware(ctx context.Context, device *v1alpha1.NicDevice, version string, cacheDir string) error {
+	log.Log.Info("FirmwareManager.burnBlueFieldFirmware()", "device", device.Name, "version", version)
+
+	dmsClient, err := f.dmsManager.GetDMSClientBySerialNumber(device.Status.SerialNumber)
+	if err != nil {
+		log.Log.Error(err, "failed to get DMS client", "device", device.Name)
+		return err
+	}
+
+	bfbFolderPath := filepath.Join(cacheDir, consts.BFBFolder)
+	log.Log.V(2).Info("Searching for BFB file in the cache", "bfbFolderPath", bfbFolderPath)
+
+	var bfbPath string
+	err = filepath.WalkDir(bfbFolderPath, func(path string, d os.DirEntry, err error) error {
+		if err == nil && strings.EqualFold(filepath.Ext(d.Name()), ".bfb") {
+			log.Log.V(2).Info("Found BFB file", "path", path)
+			bfbPath = path
+			return filepath.SkipAll
+		}
+		return nil
+	})
+	if err != nil {
+		log.Log.Error(err, "failed to search for BFB file", "bfbFolderPath", bfbFolderPath)
+		return err
+	}
+
+	if bfbPath == "" {
+		err := fmt.Errorf("couldn't find BFB file for version %s", version)
+		log.Log.Error(err, "failed to upgrade FW on BlueField device", "device", device.Name)
+		return err
+	}
+
+	err = dmsClient.InstallBFB(ctx, version, bfbPath)
+	if err != nil {
+		log.Log.Error(err, "failed to install BFB", "device", device.Name)
+		return err
+	}
+
+	return nil
+}
+
+// burnDefaultFirmware handles firmware updates for regular NIC devices using binary files
+func (f firmwareManager) burnDefaultFirmware(ctx context.Context, device *v1alpha1.NicDevice, version string, cacheDir string) error {
+	log.Log.Info("FirmwareManager.burnDefaultFirmware()", "device", device.Name, "version", version)
+
 	devicePSID := device.Status.PSID
 
 	log.Log.V(2).Info("Searching for FW binary in the cache", "cacheDir", cacheDir, "PSID", devicePSID)
@@ -187,6 +254,6 @@ func (f firmwareManager) BurnNicFirmware(ctx context.Context, device *v1alpha1.N
 	return nil
 }
 
-func NewFirmwareManager(client client.Client, namespace string) FirmwareManager {
-	return &firmwareManager{client: client, cacheRootDir: consts.NicFirmwareStorage, namespace: namespace, tmpDir: consts.TempDir, utils: newFirmwareUtils()}
+func NewFirmwareManager(client client.Client, dmsManager dms.DMSManager, namespace string) FirmwareManager {
+	return &firmwareManager{client: client, dmsManager: dmsManager, cacheRootDir: consts.NicFirmwareStorage, namespace: namespace, tmpDir: consts.TempDir, utils: newFirmwareUtils()}
 }