14307506029

Committed 07 Apr 2025 11:01AM UTC coverage: 61.542% (+13.0%) from 48.541%

Build # 14307506029

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #870 from SchSeba/remove_client

Remove auto generated client

Run Details

37 of 76 new or added lines in 9 files covered. (48.68%)

523 existing lines in 19 files now uncovered.

8491 of 13797 relevant lines covered (61.54%)

0.68 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

73.23

/pkg/plugins/generic/generic_plugin.go

package generic

import (
        "errors"
        "fmt"
        "syscall"

        "sigs.k8s.io/controller-runtime/pkg/log"

        sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/helper"
        hostTypes "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/types"
        plugin "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/plugins"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
)

var PluginName = "generic"

// driver id
const (
        Vfio = iota
        VirtioVdpa
        VhostVdpa
)

// driver name
const (
        vfioPciDriver    = "vfio_pci"
        virtioVdpaDriver = "virtio_vdpa"
        vhostVdpaDriver  = "vhost_vdpa"
)

// function type for determining if a given driver has to be loaded in the kernel
type needDriver func(state *sriovnetworkv1.SriovNetworkNodeState, driverState *DriverState) bool

type DriverState struct {
        DriverName     string
        DeviceType     string
        VdpaType       string
        NeedDriverFunc needDriver
        DriverLoaded   bool
}

type DriverStateMapType map[uint]*DriverState

type KargStateMapType map[string]bool

type GenericPlugin struct {
        PluginName              string
        DesireState             *sriovnetworkv1.SriovNetworkNodeState
        DriverStateMap          DriverStateMapType
        DesiredKernelArgs       KargStateMapType
        helpers                 helper.HostHelpersInterface
        skipVFConfiguration     bool
        skipBridgeConfiguration bool
}

type Option = func(c *genericPluginOptions)

// WithSkipVFConfiguration configures generic plugin to skip configuration of the VFs.
// In this case PFs will be configured and VFs are created only, VF configuration phase is skipped.
// VFs on the PF (if the PF is not ExternallyManaged) will have no driver after the plugin execution completes.
func WithSkipVFConfiguration() Option {
        return func(c *genericPluginOptions) {
                c.skipVFConfiguration = true
        }
}

// WithSkipBridgeConfiguration configures generic_plugin to skip configuration of the managed bridges
func WithSkipBridgeConfiguration() Option {
        return func(c *genericPluginOptions) {
                c.skipBridgeConfiguration = true
        }
}

type genericPluginOptions struct {
        skipVFConfiguration     bool
        skipBridgeConfiguration bool
}

const scriptsPath = "bindata/scripts/kargs.sh"

// Initialize our plugin and set up initial values
func NewGenericPlugin(helpers helper.HostHelpersInterface, options ...Option) (plugin.VendorPlugin, error) {
        cfg := &genericPluginOptions{}
        for _, o := range options {
                o(cfg)
        }
        driverStateMap := make(map[uint]*DriverState)
        driverStateMap[Vfio] = &DriverState{
                DriverName:     vfioPciDriver,
                DeviceType:     consts.DeviceTypeVfioPci,
                VdpaType:       "",
                NeedDriverFunc: needDriverCheckDeviceType,
                DriverLoaded:   false,
        }
        driverStateMap[VirtioVdpa] = &DriverState{
                DriverName:     virtioVdpaDriver,
                DeviceType:     consts.DeviceTypeNetDevice,
                VdpaType:       consts.VdpaTypeVirtio,
                NeedDriverFunc: needDriverCheckVdpaType,
                DriverLoaded:   false,
        }
        driverStateMap[VhostVdpa] = &DriverState{
                DriverName:     vhostVdpaDriver,
                DeviceType:     consts.DeviceTypeNetDevice,
                VdpaType:       consts.VdpaTypeVhost,
                NeedDriverFunc: needDriverCheckVdpaType,
                DriverLoaded:   false,
        }

        // To maintain backward compatibility we don't remove the intel_iommu, iommu and pcirealloc
        // kernel args if they are configured
        kargs, err := helpers.GetCurrentKernelArgs()
        if err != nil {
                return nil, err
        }
        desiredKernelArgs := KargStateMapType{
                consts.KernelArgPciRealloc:    helpers.IsKernelArgsSet(kargs, consts.KernelArgPciRealloc),
                consts.KernelArgIntelIommu:    helpers.IsKernelArgsSet(kargs, consts.KernelArgIntelIommu),
                consts.KernelArgIommuPt:       helpers.IsKernelArgsSet(kargs, consts.KernelArgIommuPt),
                consts.KernelArgRdmaShared:    false,
                consts.KernelArgRdmaExclusive: false,
        }

        return &GenericPlugin{
                PluginName:              PluginName,
                DriverStateMap:          driverStateMap,
                DesiredKernelArgs:       desiredKernelArgs,
                helpers:                 helpers,
                skipVFConfiguration:     cfg.skipVFConfiguration,
                skipBridgeConfiguration: cfg.skipBridgeConfiguration,
        }, nil
}

// Name returns the name of the plugin
func (p *GenericPlugin) Name() string {
        return p.PluginName
}

// OnNodeStateChange Invoked when SriovNetworkNodeState CR is created or updated, return if need drain and/or reboot node
func (p *GenericPlugin) OnNodeStateChange(new *sriovnetworkv1.SriovNetworkNodeState) (needDrain bool, needReboot bool, err error) {
        log.Log.Info("generic plugin OnNodeStateChange()")
        p.DesireState = new

        needDrain = p.needDrainNode(new.Spec, new.Status)
        needReboot, err = p.needRebootNode(new)
        if err != nil {
                return needDrain, needReboot, err
        }

        if needReboot {
                needDrain = true
        }
        return
}

// CheckStatusChanges verify whether SriovNetworkNodeState CR status present changes on configured VFs.
func (p *GenericPlugin) CheckStatusChanges(current *sriovnetworkv1.SriovNetworkNodeState) (bool, error) {
        log.Log.Info("generic-plugin CheckStatusChanges()")

        for _, iface := range current.Spec.Interfaces {
                found := false
                for _, ifaceStatus := range current.Status.Interfaces {
                        // TODO: remove the check for ExternallyManaged - https://github.com/k8snetworkplumbingwg/sriov-network-operator/issues/632
                        if iface.PciAddress == ifaceStatus.PciAddress && !iface.ExternallyManaged {
                                found = true
                                if sriovnetworkv1.NeedToUpdateSriov(&iface, &ifaceStatus) {
                                        log.Log.Info("CheckStatusChanges(): status changed for interface", "address", iface.PciAddress)
                                        return true, nil
                                }
                                break
                        }
                }
                if !found {
                        log.Log.Info("CheckStatusChanges(): no status found for interface", "address", iface.PciAddress)
                }
        }

        if p.shouldConfigureBridges() {
                if sriovnetworkv1.NeedToUpdateBridges(&current.Spec.Bridges, &current.Status.Bridges) {
                        log.Log.Info("CheckStatusChanges(): bridge configuration needs to be updated")
                        return true, nil
                }
        }

        shouldUpdate, err := p.shouldUpdateKernelArgs()
        if err != nil {
                log.Log.Error(err, "generic-plugin CheckStatusChanges(): failed to verify missing kernel arguments")
                return false, err
        }

        return shouldUpdate, nil
}

func (p *GenericPlugin) syncDriverState() error {
        for _, driverState := range p.DriverStateMap {
                if !driverState.DriverLoaded && driverState.NeedDriverFunc(p.DesireState, driverState) {
                        log.Log.V(2).Info("loading driver", "name", driverState.DriverName)
                        if err := p.helpers.LoadKernelModule(driverState.DriverName); err != nil {
                                log.Log.Error(err, "generic plugin syncDriverState(): fail to load kmod", "name", driverState.DriverName)
                                return err
                        }
                        driverState.DriverLoaded = true
                }
        }
        return nil
}

// Apply config change
func (p *GenericPlugin) Apply() error {
        log.Log.Info("generic plugin Apply()", "desiredState", p.DesireState.Spec)

        if err := p.syncDriverState(); err != nil {
                return err
        }

        // When calling from systemd do not try to chroot
        if !vars.UsingSystemdMode {
                exit, err := p.helpers.Chroot(consts.Host)
                if err != nil {
                        return err
                }
                defer exit()
        }

        if err := p.helpers.ConfigSriovInterfaces(p.helpers, p.DesireState.Spec.Interfaces,
                p.DesireState.Status.Interfaces, p.skipVFConfiguration); err != nil {
                // Catch the "cannot allocate memory" error and try to use PCI realloc
                if errors.Is(err, syscall.ENOMEM) {
                        p.enableDesiredKernelArgs(consts.KernelArgPciRealloc)
                }
                return err
        }

        if p.shouldConfigureBridges() {
                if err := p.helpers.ConfigureBridges(p.DesireState.Spec.Bridges, p.DesireState.Status.Bridges); err != nil {
                        return err
                }
        }

        return nil
}

func needDriverCheckDeviceType(state *sriovnetworkv1.SriovNetworkNodeState, driverState *DriverState) bool {
        for _, iface := range state.Spec.Interfaces {
                for i := range iface.VfGroups {
                        if iface.VfGroups[i].DeviceType == driverState.DeviceType {
                                return true
                        }
                }
        }
        return false
}

func needDriverCheckVdpaType(state *sriovnetworkv1.SriovNetworkNodeState, driverState *DriverState) bool {
        for _, iface := range state.Spec.Interfaces {
                for i := range iface.VfGroups {
                        if iface.VfGroups[i].VdpaType == driverState.VdpaType {
                                return true
                        }
                }
        }
        return false
}

// editKernelArg Tries to add the kernel args via ostree or grubby.
func editKernelArg(helper helper.HostHelpersInterface, mode, karg string) error {
        log.Log.Info("generic plugin editKernelArg()", "mode", mode, "karg", karg)
        _, _, err := helper.RunCommand("/bin/sh", scriptsPath, mode, karg)
        if err != nil {
                // if grubby is not there log and assume kernel args are set correctly.
                if utils.IsCommandNotFound(err) {
                        log.Log.Error(err, "generic plugin editKernelArg(): grubby or ostree command not found. Please ensure that kernel arg are correct",
                                "kargs", karg)
                        return nil
                }
                log.Log.Error(err, "generic plugin editKernelArg(): fail to edit kernel arg", "karg", karg)
                return err
        }
        return nil
}

// enableDesiredKernelArgs Should be called to mark a kernel arg as enabled.
func (p *GenericPlugin) enableDesiredKernelArgs(karg string) {
        log.Log.Info("generic plugin enableDesiredKernelArgs(): enable kernel arg", "karg", karg)
        p.DesiredKernelArgs[karg] = true
}

// disableDesiredKernelArgs Should be called to mark a kernel arg as disabled.
func (p *GenericPlugin) disableDesiredKernelArgs(karg string) {
        log.Log.Info("generic plugin disableDesiredKernelArgs(): disable kernel arg", "karg", karg)
        p.DesiredKernelArgs[karg] = false
}

// shouldUpdateKernelArgs returns true if the DesiredKernelArgs state is not equal to the running kernel args in the system
func (p *GenericPlugin) shouldUpdateKernelArgs() (bool, error) {
        kargs, err := p.helpers.GetCurrentKernelArgs()
        if err != nil {
                return false, err
        }

        for karg, kargState := range p.DesiredKernelArgs {
                if kargState && !p.helpers.IsKernelArgsSet(kargs, karg) {
                        return true, nil
                }

                if !kargState && p.helpers.IsKernelArgsSet(kargs, karg) {
                        return true, nil
                }
        }
        return false, nil
}

// syncDesiredKernelArgs should be called to set all the kernel arguments. Returns bool if node update is needed.
func (p *GenericPlugin) syncDesiredKernelArgs() (bool, error) {
        kargs, err := p.helpers.GetCurrentKernelArgs()
        if err != nil {
                return false, err
        }

        needReboot := false
        for karg, kargState := range p.DesiredKernelArgs {
                if kargState {
                        err = editKernelArg(p.helpers, "add", karg)
                        if err != nil {
                                log.Log.Error(err, "generic-plugin syncDesiredKernelArgs(): fail to set kernel arg", "karg", karg)
                                return false, err
                        }

                        if !p.helpers.IsKernelArgsSet(kargs, karg) {
                                needReboot = true
                        }
                } else {
                        err = editKernelArg(p.helpers, "remove", karg)
                        if err != nil {
                                log.Log.Error(err, "generic-plugin syncDesiredKernelArgs(): fail to remove kernel arg", "karg", karg)
                                return false, err
                        }

                        if p.helpers.IsKernelArgsSet(kargs, karg) {
                                needReboot = true
                        }
                }
        }
        return needReboot, nil
}

func (p *GenericPlugin) needDrainNode(desired sriovnetworkv1.SriovNetworkNodeStateSpec, current sriovnetworkv1.SriovNetworkNodeStateStatus) bool {
        log.Log.V(2).Info("generic plugin needDrainNode()", "current", current, "desired", desired)

        if p.needToUpdateVFs(desired, current) {
                return true
        }

        if p.shouldConfigureBridges() {
                if sriovnetworkv1.NeedToUpdateBridges(&desired.Bridges, &current.Bridges) {
                        log.Log.V(2).Info("generic plugin needDrainNode(): need drain since bridge configuration needs to be updated")
                        return true
                }
        }
        return false
}

func (p *GenericPlugin) needToUpdateVFs(desired sriovnetworkv1.SriovNetworkNodeStateSpec, current sriovnetworkv1.SriovNetworkNodeStateStatus) bool {
        for _, ifaceStatus := range current.Interfaces {
                configured := false
                for _, iface := range desired.Interfaces {
                        if iface.PciAddress == ifaceStatus.PciAddress {
                                configured = true
                                if ifaceStatus.NumVfs == 0 {
                                        log.Log.V(2).Info("generic plugin needToUpdateVFs(): no need drain, for PCI address, current NumVfs is 0",
                                                "address", iface.PciAddress)
                                        break
                                }
                                if sriovnetworkv1.NeedToUpdateSriov(&iface, &ifaceStatus) {
                                        log.Log.V(2).Info("generic plugin needToUpdateVFs(): need drain, for PCI address request update",
                                                "address", iface.PciAddress)
                                        return true
                                }
                                log.Log.V(2).Info("generic plugin needToUpdateVFs(): no need drain,for PCI address",
                                        "address", iface.PciAddress, "expected-vfs", iface.NumVfs, "current-vfs", ifaceStatus.NumVfs)
                        }
                }
                if !configured && ifaceStatus.NumVfs > 0 {
                        // load the PF info
                        pfStatus, exist, err := p.helpers.LoadPfsStatus(ifaceStatus.PciAddress)
                        if err != nil {
                                log.Log.Error(err, "generic plugin needToUpdateVFs(): failed to load info about PF status for pci device",
                                        "address", ifaceStatus.PciAddress)
                                continue
                        }

                        if !exist {
                                log.Log.Info("generic plugin needToUpdateVFs(): PF name with pci address has VFs configured but they weren't created by the sriov operator. Skipping drain",
                                        "name", ifaceStatus.Name,
                                        "address", ifaceStatus.PciAddress)
                                continue
                        }

                        if pfStatus.ExternallyManaged {
                                log.Log.Info("generic plugin needToUpdateVFs(): PF name with pci address was externally created. Skipping drain",
                                        "name", ifaceStatus.Name,
                                        "address", ifaceStatus.PciAddress)
                                continue
                        }

                        log.Log.V(2).Info("generic plugin needToUpdateVFs(): need drain since interface needs to be reset",
                                "interface", ifaceStatus)
                        return true
                }
        }
        return false
}

func (p *GenericPlugin) shouldConfigureBridges() bool {
        return vars.ManageSoftwareBridges && !p.skipBridgeConfiguration
}

func (p *GenericPlugin) addVfioDesiredKernelArg(state *sriovnetworkv1.SriovNetworkNodeState) {
        driverState := p.DriverStateMap[Vfio]

        kernelArgFnByCPUVendor := map[hostTypes.CPUVendor]func(){
                hostTypes.CPUVendorIntel: func() {
                        p.enableDesiredKernelArgs(consts.KernelArgIntelIommu)
                        p.enableDesiredKernelArgs(consts.KernelArgIommuPt)
                },
                hostTypes.CPUVendorAMD: func() {
                        p.enableDesiredKernelArgs(consts.KernelArgIommuPt)
                },
        }

        if !driverState.DriverLoaded && driverState.NeedDriverFunc(state, driverState) {
                cpuVendor, err := p.helpers.GetCPUVendor()
                if err != nil {
                        log.Log.Error(err, "can't get CPU vendor, falling back to Intel")
                        cpuVendor = hostTypes.CPUVendorIntel
                }

                addKernelArgFn := kernelArgFnByCPUVendor[cpuVendor]
                if addKernelArgFn != nil {
                        addKernelArgFn()
                }
        }
}

func (p *GenericPlugin) configRdmaKernelArg(state *sriovnetworkv1.SriovNetworkNodeState) error {
        if state.Spec.System.RdmaMode == "" {
                p.disableDesiredKernelArgs(consts.KernelArgRdmaExclusive)
                p.disableDesiredKernelArgs(consts.KernelArgRdmaShared)
        } else if state.Spec.System.RdmaMode == "shared" {
                p.enableDesiredKernelArgs(consts.KernelArgRdmaShared)
                p.disableDesiredKernelArgs(consts.KernelArgRdmaExclusive)
        } else if state.Spec.System.RdmaMode == "exclusive" {
                p.enableDesiredKernelArgs(consts.KernelArgRdmaExclusive)
                p.disableDesiredKernelArgs(consts.KernelArgRdmaShared)
        } else {
                err := fmt.Errorf("unexpected rdma mode: %s", state.Spec.System.RdmaMode)
                log.Log.Error(err, "generic-plugin configRdmaKernelArg(): failed to configure kernel arguments for rdma")
                return err
        }

        return p.helpers.SetRDMASubsystem(state.Spec.System.RdmaMode)
}

func (p *GenericPlugin) needRebootNode(state *sriovnetworkv1.SriovNetworkNodeState) (bool, error) {
        needReboot := false

        p.addVfioDesiredKernelArg(state)
        err := p.configRdmaKernelArg(state)
        if err != nil {
                return false, err
        }

        needReboot, err = p.syncDesiredKernelArgs()
        if err != nil {
                log.Log.Error(err, "generic-plugin needRebootNode(): failed to set the desired kernel arguments")
                return false, err
        }
        if needReboot {
                log.Log.V(2).Info("generic-plugin needRebootNode(): need reboot for updating kernel arguments")
        }

        return needReboot, nil
}

// ////////////// for testing purposes only ///////////////////////
func (p *GenericPlugin) getDriverStateMap() DriverStateMapType {
        return p.DriverStateMap
}

func (p *GenericPlugin) loadDriverForTests(state *sriovnetworkv1.SriovNetworkNodeState) {
        for _, driverState := range p.DriverStateMap {
                if !driverState.DriverLoaded && driverState.NeedDriverFunc(state, driverState) {
                        driverState.DriverLoaded = true
                }
        }
}

//////////////////////////////////////////////////////////////////

1	package generic
2
3	import (
4	"errors"
5	"fmt"
6	"syscall"
7
8	"sigs.k8s.io/controller-runtime/pkg/log"
9
10	sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
11	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
12	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/helper"
13	hostTypes "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/types"
14	plugin "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/plugins"
15	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
16	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
17	)
18
19	var PluginName = "generic"
20
21	// driver id
22	const (
23	Vfio = iota
24	VirtioVdpa
25	VhostVdpa
26	)
27
28	// driver name
29	const (
30	vfioPciDriver = "vfio_pci"
31	virtioVdpaDriver = "virtio_vdpa"
32	vhostVdpaDriver = "vhost_vdpa"
33	)
34
35	// function type for determining if a given driver has to be loaded in the kernel
36	type needDriver func(state sriovnetworkv1.SriovNetworkNodeState, driverState DriverState) bool
37
38	type DriverState struct {
39	DriverName string
40	DeviceType string
41	VdpaType string
42	NeedDriverFunc needDriver
43	DriverLoaded bool
44	}
45
46	type DriverStateMapType map[uint]*DriverState
47
48	type KargStateMapType map[string]bool
49
50	type GenericPlugin struct {
51	PluginName string
52	DesireState *sriovnetworkv1.SriovNetworkNodeState
53	DriverStateMap DriverStateMapType
54	DesiredKernelArgs KargStateMapType
55	helpers helper.HostHelpersInterface
56	skipVFConfiguration bool
57	skipBridgeConfiguration bool
58	}
59
60	type Option = func(c *genericPluginOptions)
61
62	// WithSkipVFConfiguration configures generic plugin to skip configuration of the VFs.
63	// In this case PFs will be configured and VFs are created only, VF configuration phase is skipped.
64	// VFs on the PF (if the PF is not ExternallyManaged) will have no driver after the plugin execution completes.
65	func WithSkipVFConfiguration() Option {	1✔
66	return func(c *genericPluginOptions) {	1✔
UNCOV 67	c.skipVFConfiguration = true	×
68	}	×
69	}
70
71	// WithSkipBridgeConfiguration configures generic_plugin to skip configuration of the managed bridges
72	func WithSkipBridgeConfiguration() Option {	1✔
73	return func(c *genericPluginOptions) {	1✔
UNCOV 74	c.skipBridgeConfiguration = true	×
75	}	×
76	}
77
78	type genericPluginOptions struct {
79	skipVFConfiguration bool
80	skipBridgeConfiguration bool
81	}
82
83	const scriptsPath = "bindata/scripts/kargs.sh"
84
85	// Initialize our plugin and set up initial values
86	func NewGenericPlugin(helpers helper.HostHelpersInterface, options ...Option) (plugin.VendorPlugin, error) {	1✔
87	cfg := &genericPluginOptions{}	1✔
88	for _, o := range options {	1✔
UNCOV 89	o(cfg)	×
90	}	×
91	driverStateMap := make(map[uint]*DriverState)	1✔
92	driverStateMap[Vfio] = &DriverState{	1✔
93	DriverName: vfioPciDriver,	1✔
94	DeviceType: consts.DeviceTypeVfioPci,	1✔
95	VdpaType: "",	1✔
96	NeedDriverFunc: needDriverCheckDeviceType,	1✔
97	DriverLoaded: false,	1✔
98	}	1✔
99	driverStateMap[VirtioVdpa] = &DriverState{	1✔
100	DriverName: virtioVdpaDriver,	1✔
101	DeviceType: consts.DeviceTypeNetDevice,	1✔
102	VdpaType: consts.VdpaTypeVirtio,	1✔
103	NeedDriverFunc: needDriverCheckVdpaType,	1✔
104	DriverLoaded: false,	1✔
105	}	1✔
106	driverStateMap[VhostVdpa] = &DriverState{	1✔
107	DriverName: vhostVdpaDriver,	1✔
108	DeviceType: consts.DeviceTypeNetDevice,	1✔
109	VdpaType: consts.VdpaTypeVhost,	1✔
110	NeedDriverFunc: needDriverCheckVdpaType,	1✔
111	DriverLoaded: false,	1✔
112	}	1✔
113		1✔
114	// To maintain backward compatibility we don't remove the intel_iommu, iommu and pcirealloc	1✔
115	// kernel args if they are configured	1✔
116	kargs, err := helpers.GetCurrentKernelArgs()	1✔
117	if err != nil {	1✔
UNCOV 118	return nil, err	×
119	}	×
120	desiredKernelArgs := KargStateMapType{	1✔
121	consts.KernelArgPciRealloc: helpers.IsKernelArgsSet(kargs, consts.KernelArgPciRealloc),	1✔
122	consts.KernelArgIntelIommu: helpers.IsKernelArgsSet(kargs, consts.KernelArgIntelIommu),	1✔
123	consts.KernelArgIommuPt: helpers.IsKernelArgsSet(kargs, consts.KernelArgIommuPt),	1✔
124	consts.KernelArgRdmaShared: false,	1✔
125	consts.KernelArgRdmaExclusive: false,	1✔
126	}	1✔
127		1✔
128	return &GenericPlugin{	1✔
129	PluginName: PluginName,	1✔
130	DriverStateMap: driverStateMap,	1✔
131	DesiredKernelArgs: desiredKernelArgs,	1✔
132	helpers: helpers,	1✔
133	skipVFConfiguration: cfg.skipVFConfiguration,	1✔
134	skipBridgeConfiguration: cfg.skipBridgeConfiguration,	1✔
135	}, nil	1✔
136	}
137
138	// Name returns the name of the plugin
139	func (p *GenericPlugin) Name() string {	1✔
140	return p.PluginName	1✔
141	}	1✔
142
143	// OnNodeStateChange Invoked when SriovNetworkNodeState CR is created or updated, return if need drain and/or reboot node
144	func (p GenericPlugin) OnNodeStateChange(new sriovnetworkv1.SriovNetworkNodeState) (needDrain bool, needReboot bool, err error) {	1✔
145	log.Log.Info("generic plugin OnNodeStateChange()")	1✔
146	p.DesireState = new	1✔
147		1✔
148	needDrain = p.needDrainNode(new.Spec, new.Status)	1✔
149	needReboot, err = p.needRebootNode(new)	1✔
150	if err != nil {	1✔
UNCOV 151	return needDrain, needReboot, err	×
UNCOV 152	}	×
153
154	if needReboot {	1✔
UNCOV 155	needDrain = true	×
UNCOV 156	}	×
157	return	1✔
158	}
159
160	// CheckStatusChanges verify whether SriovNetworkNodeState CR status present changes on configured VFs.
161	func (p GenericPlugin) CheckStatusChanges(current sriovnetworkv1.SriovNetworkNodeState) (bool, error) {	1✔
162	log.Log.Info("generic-plugin CheckStatusChanges()")	1✔
163		1✔
164	for _, iface := range current.Spec.Interfaces {	2✔
165	found := false	1✔
166	for _, ifaceStatus := range current.Status.Interfaces {	2✔
167	// TODO: remove the check for ExternallyManaged - https://github.com/k8snetworkplumbingwg/sriov-network-operator/issues/632	1✔
168	if iface.PciAddress == ifaceStatus.PciAddress && !iface.ExternallyManaged {	2✔
169	found = true	1✔
170	if sriovnetworkv1.NeedToUpdateSriov(&iface, &ifaceStatus) {	2✔
171	log.Log.Info("CheckStatusChanges(): status changed for interface", "address", iface.PciAddress)	1✔
172	return true, nil	1✔
173	}	1✔
174	break	1✔
175	}
176	}
177	if !found {	1✔
UNCOV 178	log.Log.Info("CheckStatusChanges(): no status found for interface", "address", iface.PciAddress)	×
UNCOV 179	}	×
180	}
181
182	if p.shouldConfigureBridges() {	2✔
183	if sriovnetworkv1.NeedToUpdateBridges(&current.Spec.Bridges, &current.Status.Bridges) {	2✔
184	log.Log.Info("CheckStatusChanges(): bridge configuration needs to be updated")	1✔
185	return true, nil	1✔
186	}	1✔
187	}
188
189	shouldUpdate, err := p.shouldUpdateKernelArgs()	1✔
190	if err != nil {	1✔
UNCOV 191	log.Log.Error(err, "generic-plugin CheckStatusChanges(): failed to verify missing kernel arguments")	×
UNCOV 192	return false, err	×
UNCOV 193	}	×
194
195	return shouldUpdate, nil	1✔
196	}
197
198	func (p *GenericPlugin) syncDriverState() error {	1✔
199	for _, driverState := range p.DriverStateMap {	2✔
200	if !driverState.DriverLoaded && driverState.NeedDriverFunc(p.DesireState, driverState) {	1✔
UNCOV 201	log.Log.V(2).Info("loading driver", "name", driverState.DriverName)	×
UNCOV 202	if err := p.helpers.LoadKernelModule(driverState.DriverName); err != nil {	×
UNCOV 203	log.Log.Error(err, "generic plugin syncDriverState(): fail to load kmod", "name", driverState.DriverName)	×
UNCOV 204	return err	×
UNCOV 205	}	×
UNCOV 206	driverState.DriverLoaded = true	×
207	}
208	}
209	return nil	1✔
210	}
211
212	// Apply config change
213	func (p *GenericPlugin) Apply() error {	1✔
214	log.Log.Info("generic plugin Apply()", "desiredState", p.DesireState.Spec)	1✔
215		1✔
216	if err := p.syncDriverState(); err != nil {	1✔
UNCOV 217	return err	×
UNCOV 218	}	×
219
220	// When calling from systemd do not try to chroot
221	if !vars.UsingSystemdMode {	2✔
222	exit, err := p.helpers.Chroot(consts.Host)	1✔
223	if err != nil {	1✔
224	return err	×
225	}	×
226	defer exit()	1✔
227	}
228
229	if err := p.helpers.ConfigSriovInterfaces(p.helpers, p.DesireState.Spec.Interfaces,	1✔
230	p.DesireState.Status.Interfaces, p.skipVFConfiguration); err != nil {	1✔
231	// Catch the "cannot allocate memory" error and try to use PCI realloc	×
232	if errors.Is(err, syscall.ENOMEM) {	×
UNCOV 233	p.enableDesiredKernelArgs(consts.KernelArgPciRealloc)	×
UNCOV 234	}	×
UNCOV 235	return err	×
236	}
237
238	if p.shouldConfigureBridges() {	1✔
239	if err := p.helpers.ConfigureBridges(p.DesireState.Spec.Bridges, p.DesireState.Status.Bridges); err != nil {	×
240	return err	×
241	}	×
242	}
243
244	return nil	1✔
245	}
246
247	func needDriverCheckDeviceType(state sriovnetworkv1.SriovNetworkNodeState, driverState DriverState) bool {	1✔
248	for _, iface := range state.Spec.Interfaces {	2✔
249	for i := range iface.VfGroups {	2✔
250	if iface.VfGroups[i].DeviceType == driverState.DeviceType {	2✔
251	return true	1✔
252	}	1✔
253	}
254	}
255	return false	1✔
256	}
257
258	func needDriverCheckVdpaType(state sriovnetworkv1.SriovNetworkNodeState, driverState DriverState) bool {	1✔
259	for _, iface := range state.Spec.Interfaces {	2✔
260	for i := range iface.VfGroups {	2✔
261	if iface.VfGroups[i].VdpaType == driverState.VdpaType {	2✔
262	return true	1✔
263	}	1✔
264	}
265	}
266	return false	1✔
267	}
268
269	// editKernelArg Tries to add the kernel args via ostree or grubby.
270	func editKernelArg(helper helper.HostHelpersInterface, mode, karg string) error {	1✔
271	log.Log.Info("generic plugin editKernelArg()", "mode", mode, "karg", karg)	1✔
272	_, _, err := helper.RunCommand("/bin/sh", scriptsPath, mode, karg)	1✔
273	if err != nil {	1✔
UNCOV 274	// if grubby is not there log and assume kernel args are set correctly.	×
UNCOV 275	if utils.IsCommandNotFound(err) {	×
UNCOV 276	log.Log.Error(err, "generic plugin editKernelArg(): grubby or ostree command not found. Please ensure that kernel arg are correct",	×
UNCOV 277	"kargs", karg)	×
UNCOV 278	return nil	×
UNCOV 279	}	×
UNCOV 280	log.Log.Error(err, "generic plugin editKernelArg(): fail to edit kernel arg", "karg", karg)	×
281	return err	×
282	}
283	return nil	1✔
284	}
285
286	// enableDesiredKernelArgs Should be called to mark a kernel arg as enabled.
287	func (p *GenericPlugin) enableDesiredKernelArgs(karg string) {	1✔
288	log.Log.Info("generic plugin enableDesiredKernelArgs(): enable kernel arg", "karg", karg)	1✔
289	p.DesiredKernelArgs[karg] = true	1✔
290	}	1✔
291
292	// disableDesiredKernelArgs Should be called to mark a kernel arg as disabled.
293	func (p *GenericPlugin) disableDesiredKernelArgs(karg string) {	1✔
294	log.Log.Info("generic plugin disableDesiredKernelArgs(): disable kernel arg", "karg", karg)	1✔
295	p.DesiredKernelArgs[karg] = false	1✔
296	}	1✔
297
298	// shouldUpdateKernelArgs returns true if the DesiredKernelArgs state is not equal to the running kernel args in the system
299	func (p *GenericPlugin) shouldUpdateKernelArgs() (bool, error) {	1✔
300	kargs, err := p.helpers.GetCurrentKernelArgs()	1✔
301	if err != nil {	1✔
UNCOV 302	return false, err	×
UNCOV 303	}	×
304
305	for karg, kargState := range p.DesiredKernelArgs {	2✔
306	if kargState && !p.helpers.IsKernelArgsSet(kargs, karg) {	2✔
307	return true, nil	1✔
308	}	1✔
309
310	if !kargState && p.helpers.IsKernelArgsSet(kargs, karg) {	1✔
UNCOV 311	return true, nil	×
UNCOV 312	}	×
313	}
314	return false, nil	1✔
315	}
316
317	// syncDesiredKernelArgs should be called to set all the kernel arguments. Returns bool if node update is needed.
318	func (p *GenericPlugin) syncDesiredKernelArgs() (bool, error) {	1✔
319	kargs, err := p.helpers.GetCurrentKernelArgs()	1✔
320	if err != nil {	1✔
UNCOV 321	return false, err	×
UNCOV 322	}	×
323
324	needReboot := false	1✔
325	for karg, kargState := range p.DesiredKernelArgs {	2✔
326	if kargState {	2✔
327	err = editKernelArg(p.helpers, "add", karg)	1✔
328	if err != nil {	1✔
329	log.Log.Error(err, "generic-plugin syncDesiredKernelArgs(): fail to set kernel arg", "karg", karg)	×
UNCOV 330	return false, err	×
UNCOV 331	}	×
332
333	if !p.helpers.IsKernelArgsSet(kargs, karg) {	1✔
UNCOV 334	needReboot = true	×
UNCOV 335	}	×
336	} else {	1✔
337	err = editKernelArg(p.helpers, "remove", karg)	1✔
338	if err != nil {	1✔
UNCOV 339	log.Log.Error(err, "generic-plugin syncDesiredKernelArgs(): fail to remove kernel arg", "karg", karg)	×
UNCOV 340	return false, err	×
341	}	×
342
343	if p.helpers.IsKernelArgsSet(kargs, karg) {	1✔
UNCOV 344	needReboot = true	×
UNCOV 345	}	×
346	}
347	}
348	return needReboot, nil	1✔
349	}
350
351	func (p *GenericPlugin) needDrainNode(desired sriovnetworkv1.SriovNetworkNodeStateSpec, current sriovnetworkv1.SriovNetworkNodeStateStatus) bool {	1✔
352	log.Log.V(2).Info("generic plugin needDrainNode()", "current", current, "desired", desired)	1✔
353		1✔
354	if p.needToUpdateVFs(desired, current) {	2✔
355	return true	1✔
356	}	1✔
357
358	if p.shouldConfigureBridges() {	2✔
359	if sriovnetworkv1.NeedToUpdateBridges(&desired.Bridges, &current.Bridges) {	2✔
360	log.Log.V(2).Info("generic plugin needDrainNode(): need drain since bridge configuration needs to be updated")	1✔
361	return true	1✔
362	}	1✔
363	}
364	return false	1✔
365	}
366
367	func (p *GenericPlugin) needToUpdateVFs(desired sriovnetworkv1.SriovNetworkNodeStateSpec, current sriovnetworkv1.SriovNetworkNodeStateStatus) bool {	1✔
368	for _, ifaceStatus := range current.Interfaces {	2✔
369	configured := false	1✔
370	for _, iface := range desired.Interfaces {	2✔
371	if iface.PciAddress == ifaceStatus.PciAddress {	2✔
372	configured = true	1✔
373	if ifaceStatus.NumVfs == 0 {	1✔
UNCOV 374	log.Log.V(2).Info("generic plugin needToUpdateVFs(): no need drain, for PCI address, current NumVfs is 0",	×
UNCOV 375	"address", iface.PciAddress)	×
UNCOV 376	break	×
377	}
378	if sriovnetworkv1.NeedToUpdateSriov(&iface, &ifaceStatus) {	2✔
379	log.Log.V(2).Info("generic plugin needToUpdateVFs(): need drain, for PCI address request update",	1✔
380	"address", iface.PciAddress)	1✔
381	return true	1✔
382	}	1✔
383	log.Log.V(2).Info("generic plugin needToUpdateVFs(): no need drain,for PCI address",	1✔
384	"address", iface.PciAddress, "expected-vfs", iface.NumVfs, "current-vfs", ifaceStatus.NumVfs)	1✔
385	}
386	}
387	if !configured && ifaceStatus.NumVfs > 0 {	2✔
388	// load the PF info	1✔
389	pfStatus, exist, err := p.helpers.LoadPfsStatus(ifaceStatus.PciAddress)	1✔
390	if err != nil {	1✔
UNCOV 391	log.Log.Error(err, "generic plugin needToUpdateVFs(): failed to load info about PF status for pci device",	×
UNCOV 392	"address", ifaceStatus.PciAddress)	×
UNCOV 393	continue	×
394	}
395
396	if !exist {	1✔
UNCOV 397	log.Log.Info("generic plugin needToUpdateVFs(): PF name with pci address has VFs configured but they weren't created by the sriov operator. Skipping drain",	×
398	"name", ifaceStatus.Name,	×
399	"address", ifaceStatus.PciAddress)	×
400	continue	×
401	}
402
403	if pfStatus.ExternallyManaged {	1✔
404	log.Log.Info("generic plugin needToUpdateVFs(): PF name with pci address was externally created. Skipping drain",	×
405	"name", ifaceStatus.Name,	×
406	"address", ifaceStatus.PciAddress)	×
407	continue	×
408	}
409
410	log.Log.V(2).Info("generic plugin needToUpdateVFs(): need drain since interface needs to be reset",	1✔
411	"interface", ifaceStatus)	1✔
412	return true	1✔
413	}
414	}
415	return false	1✔
416	}
417
418	func (p *GenericPlugin) shouldConfigureBridges() bool {	1✔
419	return vars.ManageSoftwareBridges && !p.skipBridgeConfiguration	1✔
420	}	1✔
421
422	func (p GenericPlugin) addVfioDesiredKernelArg(state sriovnetworkv1.SriovNetworkNodeState) {	1✔
423	driverState := p.DriverStateMap[Vfio]	1✔
424		1✔
425	kernelArgFnByCPUVendor := map[hostTypes.CPUVendor]func(){	1✔
426	hostTypes.CPUVendorIntel: func() {	2✔
427	p.enableDesiredKernelArgs(consts.KernelArgIntelIommu)	1✔
428	p.enableDesiredKernelArgs(consts.KernelArgIommuPt)	1✔
429	},	1✔
430	hostTypes.CPUVendorAMD: func() {	1✔
431	p.enableDesiredKernelArgs(consts.KernelArgIommuPt)	1✔
432	},	1✔
433	}
434
435	if !driverState.DriverLoaded && driverState.NeedDriverFunc(state, driverState) {	2✔
436	cpuVendor, err := p.helpers.GetCPUVendor()	1✔
437	if err != nil {	1✔
UNCOV 438	log.Log.Error(err, "can't get CPU vendor, falling back to Intel")	×
UNCOV 439	cpuVendor = hostTypes.CPUVendorIntel	×
UNCOV 440	}	×
441
442	addKernelArgFn := kernelArgFnByCPUVendor[cpuVendor]	1✔
443	if addKernelArgFn != nil {	2✔
444	addKernelArgFn()	1✔
445	}	1✔
446	}
447	}
448
449	func (p GenericPlugin) configRdmaKernelArg(state sriovnetworkv1.SriovNetworkNodeState) error {	1✔
450	if state.Spec.System.RdmaMode == "" {	2✔
451	p.disableDesiredKernelArgs(consts.KernelArgRdmaExclusive)	1✔
452	p.disableDesiredKernelArgs(consts.KernelArgRdmaShared)	1✔
453	} else if state.Spec.System.RdmaMode == "shared" {	3✔
454	p.enableDesiredKernelArgs(consts.KernelArgRdmaShared)	1✔
455	p.disableDesiredKernelArgs(consts.KernelArgRdmaExclusive)	1✔
456	} else if state.Spec.System.RdmaMode == "exclusive" {	3✔
457	p.enableDesiredKernelArgs(consts.KernelArgRdmaExclusive)	1✔
458	p.disableDesiredKernelArgs(consts.KernelArgRdmaShared)	1✔
459	} else {	1✔
UNCOV 460	err := fmt.Errorf("unexpected rdma mode: %s", state.Spec.System.RdmaMode)	×
UNCOV 461	log.Log.Error(err, "generic-plugin configRdmaKernelArg(): failed to configure kernel arguments for rdma")	×
UNCOV 462	return err	×
UNCOV 463	}	×
464
465	return p.helpers.SetRDMASubsystem(state.Spec.System.RdmaMode)	1✔
466	}
467
468	func (p GenericPlugin) needRebootNode(state sriovnetworkv1.SriovNetworkNodeState) (bool, error) {	1✔
469	needReboot := false	1✔
470		1✔
471	p.addVfioDesiredKernelArg(state)	1✔
472	err := p.configRdmaKernelArg(state)	1✔
473	if err != nil {	1✔
UNCOV 474	return false, err	×
UNCOV 475	}	×
476
477	needReboot, err = p.syncDesiredKernelArgs()	1✔
478	if err != nil {	1✔
UNCOV 479	log.Log.Error(err, "generic-plugin needRebootNode(): failed to set the desired kernel arguments")	×
UNCOV 480	return false, err	×
481	}	×
482	if needReboot {	1✔
UNCOV 483	log.Log.V(2).Info("generic-plugin needRebootNode(): need reboot for updating kernel arguments")	×
UNCOV 484	}	×
485
486	return needReboot, nil	1✔
487	}
488
489	// ////////////// for testing purposes only ///////////////////////
490	func (p *GenericPlugin) getDriverStateMap() DriverStateMapType {	1✔
491	return p.DriverStateMap	1✔
492	}	1✔
493
494	func (p GenericPlugin) loadDriverForTests(state sriovnetworkv1.SriovNetworkNodeState) {	1✔
495	for _, driverState := range p.DriverStateMap {	2✔
496	if !driverState.DriverLoaded && driverState.NeedDriverFunc(state, driverState) {	2✔
497	driverState.DriverLoaded = true	1✔
498	}	1✔
499	}
500	}
501
502	//////////////////////////////////////////////////////////////////

k8snetworkplumbingwg / sriov-network-operator / 14307506029

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous