3751025296

Build Type

github

Committed by GitHub

Commit Message

Merge 421284b55 into 788d76f7e

Pull Request Pull Request #365: Implementation for new systemd configuration method

Run Details

958 of 958 new or added lines in 18 files covered. (100.0%)

1971 of 8330 relevant lines covered (23.66%)

0.27 hits per line

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

0.0

/pkg/plugins/virtual/virtual_plugin.go

package virtual

import (
        "reflect"

        "github.com/golang/glog"
        sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
        constants "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host"
        plugin "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/plugins"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
)

var PluginName = "virtual_plugin"

// VirtualPlugin Plugin type to use on a virtual platform
type VirtualPlugin struct {
        PluginName     string
        SpecVersion    string
        DesireState    *sriovnetworkv1.SriovNetworkNodeState
        LastState      *sriovnetworkv1.SriovNetworkNodeState
        LoadVfioDriver uint
        RunningOnHost  bool
        HostManager    host.HostManagerInterface
}

const (
        unloaded = iota
        loading
        loaded
)

// Initialize our plugin and set up initial values
func NewVirtualPlugin(runningOnHost bool) (plugin.VendorPlugin, error) {
        return &VirtualPlugin{
                PluginName:     PluginName,
                SpecVersion:    "1.0",
                LoadVfioDriver: unloaded,
                RunningOnHost:  runningOnHost,
                HostManager:    host.NewHostManager(runningOnHost),
        }, nil
}

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

// Spec returns the version of the spec expected by the plugin
func (p *VirtualPlugin) Spec() string {
        return p.SpecVersion
}

// OnNodeStateChange Invoked when SriovNetworkNodeState CR is created or updated, return if need dain and/or reboot node
func (p *VirtualPlugin) OnNodeStateChange(new *sriovnetworkv1.SriovNetworkNodeState) (needDrain bool, needReboot bool, err error) {
        glog.Info("virtual-plugin OnNodeStateChange()")
        needDrain = false
        needReboot = false
        err = nil
        p.DesireState = new

        if p.LoadVfioDriver != loaded {
                if needVfioDriver(new) {
                        p.LoadVfioDriver = loading
                }
        }

        return
}

// Apply config change
func (p *VirtualPlugin) Apply() error {
        glog.Infof("virtual-plugin Apply(): desiredState=%v", p.DesireState.Spec)

        if p.LoadVfioDriver == loading {
                // In virtual deployments of Kubernetes where the underlying virtualization platform does not support a virtualized iommu
                // the VFIO PCI driver needs to be loaded with a special flag.
                // This is the case for OpenStack deployments where the underlying virtualization platform is KVM.
                // NOTE: if VFIO was already loaded for some reason, we will not try to load it again with the new options.
                kernelArgs := "enable_unsafe_noiommu_mode=1"
                if err := p.HostManager.LoadKernelModule("vfio", kernelArgs); err != nil {
                        glog.Errorf("virtual-plugin Apply(): fail to load vfio kmod: %v", err)
                        return err
                }

                if err := p.HostManager.LoadKernelModule("vfio_pci"); err != nil {
                        glog.Errorf("virtual-plugin Apply(): fail to load vfio_pci kmod: %v", err)
                        return err
                }
                p.LoadVfioDriver = loaded
        }

        if p.LastState != nil {
                glog.Infof("virtual-plugin Apply(): lastStat=%v", p.LastState.Spec)
                if reflect.DeepEqual(p.LastState.Spec.Interfaces, p.DesireState.Spec.Interfaces) {
                        glog.Info("virtual-plugin Apply(): nothing to apply")
                        return nil
                }
        }
        exit, err := utils.Chroot("/host")
        if err != nil {
                return err
        }
        defer exit()
        if err := utils.SyncNodeStateVirtual(p.DesireState); err != nil {
                return err
        }
        p.LastState = &sriovnetworkv1.SriovNetworkNodeState{}
        *p.LastState = *p.DesireState

        return nil
}

func (p *VirtualPlugin) SetSystemdFlag() {
}

func (p *VirtualPlugin) IsSystemService() bool {
        return false
}

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

1	package virtual
2
3	import (
4	"reflect"
5
6	"github.com/golang/glog"
7	sriovnetworkv1 "github.com/k8snetworkplumbingwg/sriov-network-operator/api/v1"
8	constants "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
9	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host"
10	plugin "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/plugins"
11	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
12	)
13
14	var PluginName = "virtual_plugin"
15
16	// VirtualPlugin Plugin type to use on a virtual platform
17	type VirtualPlugin struct {
18	PluginName string
19	SpecVersion string
20	DesireState *sriovnetworkv1.SriovNetworkNodeState
21	LastState *sriovnetworkv1.SriovNetworkNodeState
22	LoadVfioDriver uint
23	RunningOnHost bool
24	HostManager host.HostManagerInterface
25	}
26
27	const (
28	unloaded = iota
29	loading
30	loaded
31	)
32
33	// Initialize our plugin and set up initial values
34	func NewVirtualPlugin(runningOnHost bool) (plugin.VendorPlugin, error) {	×
35	return &VirtualPlugin{	×
36	PluginName: PluginName,	×
37	SpecVersion: "1.0",	×
38	LoadVfioDriver: unloaded,	×
39	RunningOnHost: runningOnHost,	×
40	HostManager: host.NewHostManager(runningOnHost),	×
41	}, nil	×
42	}	×
43
44	// Name returns the name of the plugin
45	func (p *VirtualPlugin) Name() string {	×
46	return p.PluginName	×
47	}	×
48
49	// Spec returns the version of the spec expected by the plugin
50	func (p *VirtualPlugin) Spec() string {	×
51	return p.SpecVersion	×
52	}	×
53
54	// OnNodeStateChange Invoked when SriovNetworkNodeState CR is created or updated, return if need dain and/or reboot node
55	func (p VirtualPlugin) OnNodeStateChange(new sriovnetworkv1.SriovNetworkNodeState) (needDrain bool, needReboot bool, err error) {	×
56	glog.Info("virtual-plugin OnNodeStateChange()")	×
57	needDrain = false	×
58	needReboot = false	×
59	err = nil	×
60	p.DesireState = new	×
61		×
62	if p.LoadVfioDriver != loaded {	×
63	if needVfioDriver(new) {	×
64	p.LoadVfioDriver = loading	×
65	}	×
66	}
67
68	return	×
69	}
70
71	// Apply config change
72	func (p *VirtualPlugin) Apply() error {	×
73	glog.Infof("virtual-plugin Apply(): desiredState=%v", p.DesireState.Spec)	×
74		×
75	if p.LoadVfioDriver == loading {	×
76	// In virtual deployments of Kubernetes where the underlying virtualization platform does not support a virtualized iommu	×
77	// the VFIO PCI driver needs to be loaded with a special flag.	×
78	// This is the case for OpenStack deployments where the underlying virtualization platform is KVM.	×
79	// NOTE: if VFIO was already loaded for some reason, we will not try to load it again with the new options.	×
80	kernelArgs := "enable_unsafe_noiommu_mode=1"	×
81	if err := p.HostManager.LoadKernelModule("vfio", kernelArgs); err != nil {	×
82	glog.Errorf("virtual-plugin Apply(): fail to load vfio kmod: %v", err)	×
83	return err	×
84	}	×
85
86	if err := p.HostManager.LoadKernelModule("vfio_pci"); err != nil {	×
87	glog.Errorf("virtual-plugin Apply(): fail to load vfio_pci kmod: %v", err)	×
88	return err	×
89	}	×
90	p.LoadVfioDriver = loaded	×
91	}
92
93	if p.LastState != nil {	×
94	glog.Infof("virtual-plugin Apply(): lastStat=%v", p.LastState.Spec)	×
95	if reflect.DeepEqual(p.LastState.Spec.Interfaces, p.DesireState.Spec.Interfaces) {	×
96	glog.Info("virtual-plugin Apply(): nothing to apply")	×
97	return nil	×
98	}	×
99	}
100	exit, err := utils.Chroot("/host")	×
101	if err != nil {	×
102	return err	×
103	}	×
104	defer exit()	×
105	if err := utils.SyncNodeStateVirtual(p.DesireState); err != nil {	×
106	return err	×
107	}	×
108	p.LastState = &sriovnetworkv1.SriovNetworkNodeState{}	×
109	p.LastState = p.DesireState	×
110		×
111	return nil	×
112	}
113
114	func (p *VirtualPlugin) SetSystemdFlag() {	×
115	}	×
116
117	func (p *VirtualPlugin) IsSystemService() bool {	×
118	return false	×
119	}	×
120
121	func needVfioDriver(state *sriovnetworkv1.SriovNetworkNodeState) bool {	×
122	for _, iface := range state.Spec.Interfaces {	×
123	for i := range iface.VfGroups {	×
124	if iface.VfGroups[i].DeviceType == constants.DeviceTypeVfioPci {	×
125	return true	×
126	}	×
127	}
128	}
129	return false	×
130	}

k8snetworkplumbingwg / sriov-network-operator / 3751025296

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