8467233545

Committed 28 Mar 2024 12:26PM UTC coverage: 38.344% (+0.7%) from 37.675%

Build # 8467233545

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #643 from ykulazhenkov/pr-turn-on-switchdev

[switchdev 9/9] Enable new switchdev implementation

Run Details

189 of 289 new or added lines in 9 files covered. (65.4%)

26 existing lines in 8 files now uncovered.

4798 of 12513 relevant lines covered (38.34%)

0.42 hits per line

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

67.86

/pkg/host/internal/udev/udev.go

package udev

import (
        "fmt"
        "os"
        "path"
        "path/filepath"
        "strings"

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

        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/types"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
        "github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
)

type udev struct {
        utilsHelper utils.CmdInterface
}

func New(utilsHelper utils.CmdInterface) types.UdevInterface {
        return &udev{utilsHelper: utilsHelper}
}

func (u *udev) PrepareNMUdevRule(supportedVfIds []string) error {
        log.Log.V(2).Info("PrepareNMUdevRule()")
        filePath := filepath.Join(vars.FilesystemRoot, consts.HostUdevRulesFolder, "10-nm-unmanaged.rules")

        // remove the old unmanaged rules file
        if _, err := os.Stat(filePath); err == nil {
                err = os.Remove(filePath)
                if err != nil {
                        log.Log.Error(err, "failed to remove the network manager global unmanaged rule",
                                "path", filePath)
                }
        }

        // create the pf finder script for udev rules
        stdout, stderr, err := u.utilsHelper.RunCommand("/bin/bash", filepath.Join(vars.FilesystemRoot, consts.UdevDisableNM))
        if err != nil {
                log.Log.Error(err, "PrepareNMUdevRule(): failed to prepare nmUdevRule", "stderr", stderr)
                return err
        }
        log.Log.V(2).Info("PrepareNMUdevRule()", "stdout", stdout)

        //save the device list to use for udev rules
        vars.SupportedVfIds = supportedVfIds
        return nil
}

// PrepareVFRepUdevRule creates a script which helps to configure representor name for the VF
func (u *udev) PrepareVFRepUdevRule() error {
        log.Log.V(2).Info("PrepareVFRepUdevRule()")
        targetPath := filepath.Join(vars.FilesystemRoot, consts.HostUdevFolder, filepath.Base(consts.UdevRepName))
        data, err := os.ReadFile(filepath.Join(vars.FilesystemRoot, consts.UdevRepName))
        if err != nil {
                log.Log.Error(err, "PrepareVFRepUdevRule(): failed to read source for representor name UDEV script")
                return err
        }
        if err := os.WriteFile(targetPath, data, 0755); err != nil {
                log.Log.Error(err, "PrepareVFRepUdevRule(): failed to write representor name UDEV script")
                return err
        }
        if err := os.Chmod(targetPath, 0755); err != nil {
                log.Log.Error(err, "PrepareVFRepUdevRule(): failed to set permissions on representor name UDEV script")
                return err
        }
        return nil
}

// AddDisableNMUdevRule adds udev rule that disables NetworkManager for VFs on the concrete PF:
func (u *udev) AddDisableNMUdevRule(pfPciAddress string) error {
        log.Log.V(2).Info("AddDisableNMUdevRule()", "device", pfPciAddress)
        udevRuleContent := fmt.Sprintf(consts.NMUdevRule, strings.Join(vars.SupportedVfIds, "|"), pfPciAddress)
        return u.addUdevRule(pfPciAddress, "10-nm-disable", udevRuleContent)
}

// RemoveDisableNMUdevRule removes udev rule that disables NetworkManager for VFs on the concrete PF
func (u *udev) RemoveDisableNMUdevRule(pfPciAddress string) error {
        log.Log.V(2).Info("RemoveDisableNMUdevRule()", "device", pfPciAddress)
        return u.removeUdevRule(pfPciAddress, "10-nm-disable")
}

// AddPersistPFNameUdevRule add udev rule that preserves PF name after switching to switchdev mode
func (u *udev) AddPersistPFNameUdevRule(pfPciAddress, pfName string) error {
        log.Log.V(2).Info("AddPersistPFNameUdevRule()", "device", pfPciAddress)
        udevRuleContent := fmt.Sprintf(consts.PFNameUdevRule, pfPciAddress, pfName)
        return u.addUdevRule(pfPciAddress, "10-pf-name", udevRuleContent)
}

// RemovePersistPFNameUdevRule removes udev rule that preserves PF name after switching to switchdev mode
func (u *udev) RemovePersistPFNameUdevRule(pfPciAddress string) error {
        log.Log.V(2).Info("RemovePersistPFNameUdevRule()", "device", pfPciAddress)
        return u.removeUdevRule(pfPciAddress, "10-pf-name")
}

// AddVfRepresentorUdevRule adds udev rule that renames VF representors on the concrete PF
func (u *udev) AddVfRepresentorUdevRule(pfPciAddress, pfName, pfSwitchID, pfSwitchPort string) error {
        log.Log.V(2).Info("AddVfRepresentorUdevRule()",
                "device", pfPciAddress, "name", pfName, "switch", pfSwitchID, "port", pfSwitchPort)
        udevRuleContent := fmt.Sprintf(consts.SwitchdevUdevRule, pfSwitchID, strings.TrimPrefix(pfSwitchPort, "p"), pfName)
        return u.addUdevRule(pfPciAddress, "20-switchdev", udevRuleContent)
}

// RemoveVfRepresentorUdevRule removes udev rule that renames VF representors on the concrete PF
func (u *udev) RemoveVfRepresentorUdevRule(pfPciAddress string) error {
        log.Log.V(2).Info("RemoveVfRepresentorUdevRule()", "device", pfPciAddress)
        return u.removeUdevRule(pfPciAddress, "20-switchdev")
}

// LoadUdevRules triggers udev rules for network subsystem
func (u *udev) LoadUdevRules() error {
        log.Log.V(2).Info("LoadUdevRules()")
        udevAdmTool := "udevadm"
        _, stderr, err := u.utilsHelper.RunCommand(udevAdmTool, "control", "--reload-rules")
        if err != nil {
                log.Log.Error(err, "LoadUdevRules(): failed to reload rules", "error", stderr)
                return err
        }
        _, stderr, err = u.utilsHelper.RunCommand(udevAdmTool, "trigger", "--action", "add", "--attr-match", "subsystem=net")
        if err != nil {
                log.Log.Error(err, "LoadUdevRules(): failed to trigger rules", "error", stderr)
                return err
        }
        return nil
}

func (u *udev) addUdevRule(pfPciAddress, ruleName, ruleContent string) error {
        log.Log.V(2).Info("addUdevRule()", "device", pfPciAddress, "rule", ruleName)
        rulePath := u.getRuleFolderPath()
        err := os.MkdirAll(rulePath, os.ModePerm)
        if err != nil && !os.IsExist(err) {
                log.Log.Error(err, "ensureUdevRulePathExist(): failed to create dir", "path", rulePath)
                return err
        }
        filePath := u.getRulePathForPF(ruleName, pfPciAddress)
        if err := os.WriteFile(filePath, []byte(ruleContent), 0666); err != nil {
                log.Log.Error(err, "addUdevRule(): fail to write file", "path", filePath)
                return err
        }
        return nil
}

func (u *udev) removeUdevRule(pfPciAddress, ruleName string) error {
        log.Log.V(2).Info("removeUdevRule()", "device", pfPciAddress, "rule", ruleName)
        rulePath := u.getRulePathForPF(ruleName, pfPciAddress)
        err := os.Remove(rulePath)
        if err != nil && !os.IsNotExist(err) {
                log.Log.Error(err, "removeUdevRule(): fail to remove rule file", "path", rulePath)
                return err
        }
        return nil
}

func (u *udev) getRuleFolderPath() string {
        return filepath.Join(vars.FilesystemRoot, consts.UdevRulesFolder)
}

func (u *udev) getRulePathForPF(ruleName, pfPciAddress string) string {
        return path.Join(u.getRuleFolderPath(), fmt.Sprintf("%s-%s.rules", ruleName, pfPciAddress))
}

1	package udev
2
3	import (
4	"fmt"
5	"os"
6	"path"
7	"path/filepath"
8	"strings"
9
10	"sigs.k8s.io/controller-runtime/pkg/log"
11
12	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/consts"
13	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/host/types"
14	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/utils"
15	"github.com/k8snetworkplumbingwg/sriov-network-operator/pkg/vars"
16	)
17
18	type udev struct {
19	utilsHelper utils.CmdInterface
20	}
21
22	func New(utilsHelper utils.CmdInterface) types.UdevInterface {	1✔
23	return &udev{utilsHelper: utilsHelper}	1✔
24	}	1✔
25
UNCOV 26	func (u *udev) PrepareNMUdevRule(supportedVfIds []string) error {	×
UNCOV 27	log.Log.V(2).Info("PrepareNMUdevRule()")	×
28	filePath := filepath.Join(vars.FilesystemRoot, consts.HostUdevRulesFolder, "10-nm-unmanaged.rules")	×
29		×
30	// remove the old unmanaged rules file	×
31	if _, err := os.Stat(filePath); err == nil {	×
32	err = os.Remove(filePath)	×
33	if err != nil {	×
34	log.Log.Error(err, "failed to remove the network manager global unmanaged rule",	×
35	"path", filePath)	×
36	}	×
37	}
38
39	// create the pf finder script for udev rules
40	stdout, stderr, err := u.utilsHelper.RunCommand("/bin/bash", filepath.Join(vars.FilesystemRoot, consts.UdevDisableNM))	×
41	if err != nil {	×
42	log.Log.Error(err, "PrepareNMUdevRule(): failed to prepare nmUdevRule", "stderr", stderr)	×
43	return err	×
44	}	×
45	log.Log.V(2).Info("PrepareNMUdevRule()", "stdout", stdout)	×
46		×
47	//save the device list to use for udev rules	×
48	vars.SupportedVfIds = supportedVfIds	×
49	return nil	×
50	}
51
52	// PrepareVFRepUdevRule creates a script which helps to configure representor name for the VF
53	func (u *udev) PrepareVFRepUdevRule() error {	1✔
54	log.Log.V(2).Info("PrepareVFRepUdevRule()")	1✔
55	targetPath := filepath.Join(vars.FilesystemRoot, consts.HostUdevFolder, filepath.Base(consts.UdevRepName))	1✔
56	data, err := os.ReadFile(filepath.Join(vars.FilesystemRoot, consts.UdevRepName))	1✔
57	if err != nil {	1✔
NEW 58	log.Log.Error(err, "PrepareVFRepUdevRule(): failed to read source for representor name UDEV script")	×
NEW 59	return err	×
UNCOV 60	}	×
61	if err := os.WriteFile(targetPath, data, 0755); err != nil {	2✔
62	log.Log.Error(err, "PrepareVFRepUdevRule(): failed to write representor name UDEV script")	1✔
63	return err	1✔
64	}	1✔
65	if err := os.Chmod(targetPath, 0755); err != nil {	1✔
NEW 66	log.Log.Error(err, "PrepareVFRepUdevRule(): failed to set permissions on representor name UDEV script")	×
NEW 67	return err	×
68	}	×
69	return nil	1✔
70	}
71
72	// AddDisableNMUdevRule adds udev rule that disables NetworkManager for VFs on the concrete PF:
73	func (u *udev) AddDisableNMUdevRule(pfPciAddress string) error {	1✔
74	log.Log.V(2).Info("AddDisableNMUdevRule()", "device", pfPciAddress)	1✔
75	udevRuleContent := fmt.Sprintf(consts.NMUdevRule, strings.Join(vars.SupportedVfIds, "\|"), pfPciAddress)	1✔
76	return u.addUdevRule(pfPciAddress, "10-nm-disable", udevRuleContent)	1✔
77	}	1✔
78
79	// RemoveDisableNMUdevRule removes udev rule that disables NetworkManager for VFs on the concrete PF
80	func (u *udev) RemoveDisableNMUdevRule(pfPciAddress string) error {	1✔
81	log.Log.V(2).Info("RemoveDisableNMUdevRule()", "device", pfPciAddress)	1✔
82	return u.removeUdevRule(pfPciAddress, "10-nm-disable")	1✔
83	}	1✔
84
85	// AddPersistPFNameUdevRule add udev rule that preserves PF name after switching to switchdev mode
86	func (u *udev) AddPersistPFNameUdevRule(pfPciAddress, pfName string) error {	1✔
87	log.Log.V(2).Info("AddPersistPFNameUdevRule()", "device", pfPciAddress)	1✔
88	udevRuleContent := fmt.Sprintf(consts.PFNameUdevRule, pfPciAddress, pfName)	1✔
89	return u.addUdevRule(pfPciAddress, "10-pf-name", udevRuleContent)	1✔
90	}	1✔
91
92	// RemovePersistPFNameUdevRule removes udev rule that preserves PF name after switching to switchdev mode
93	func (u *udev) RemovePersistPFNameUdevRule(pfPciAddress string) error {	1✔
94	log.Log.V(2).Info("RemovePersistPFNameUdevRule()", "device", pfPciAddress)	1✔
95	return u.removeUdevRule(pfPciAddress, "10-pf-name")	1✔
96	}	1✔
97
98	// AddVfRepresentorUdevRule adds udev rule that renames VF representors on the concrete PF
99	func (u *udev) AddVfRepresentorUdevRule(pfPciAddress, pfName, pfSwitchID, pfSwitchPort string) error {	1✔
100	log.Log.V(2).Info("AddVfRepresentorUdevRule()",	1✔
101	"device", pfPciAddress, "name", pfName, "switch", pfSwitchID, "port", pfSwitchPort)	1✔
102	udevRuleContent := fmt.Sprintf(consts.SwitchdevUdevRule, pfSwitchID, strings.TrimPrefix(pfSwitchPort, "p"), pfName)	1✔
103	return u.addUdevRule(pfPciAddress, "20-switchdev", udevRuleContent)	1✔
104	}	1✔
105
106	// RemoveVfRepresentorUdevRule removes udev rule that renames VF representors on the concrete PF
107	func (u *udev) RemoveVfRepresentorUdevRule(pfPciAddress string) error {	1✔
108	log.Log.V(2).Info("RemoveVfRepresentorUdevRule()", "device", pfPciAddress)	1✔
109	return u.removeUdevRule(pfPciAddress, "20-switchdev")	1✔
110	}	1✔
111
112	// LoadUdevRules triggers udev rules for network subsystem
113	func (u *udev) LoadUdevRules() error {	1✔
114	log.Log.V(2).Info("LoadUdevRules()")	1✔
115	udevAdmTool := "udevadm"	1✔
116	_, stderr, err := u.utilsHelper.RunCommand(udevAdmTool, "control", "--reload-rules")	1✔
117	if err != nil {	2✔
118	log.Log.Error(err, "LoadUdevRules(): failed to reload rules", "error", stderr)	1✔
119	return err	1✔
120	}	1✔
121	_, stderr, err = u.utilsHelper.RunCommand(udevAdmTool, "trigger", "--action", "add", "--attr-match", "subsystem=net")	1✔
122	if err != nil {	2✔
123	log.Log.Error(err, "LoadUdevRules(): failed to trigger rules", "error", stderr)	1✔
124	return err	1✔
125	}	1✔
126	return nil	1✔
127	}
128
129	func (u *udev) addUdevRule(pfPciAddress, ruleName, ruleContent string) error {	1✔
130	log.Log.V(2).Info("addUdevRule()", "device", pfPciAddress, "rule", ruleName)	1✔
131	rulePath := u.getRuleFolderPath()	1✔
132	err := os.MkdirAll(rulePath, os.ModePerm)	1✔
133	if err != nil && !os.IsExist(err) {	1✔
134	log.Log.Error(err, "ensureUdevRulePathExist(): failed to create dir", "path", rulePath)	×
135	return err	×
136	}	×
137	filePath := u.getRulePathForPF(ruleName, pfPciAddress)	1✔
138	if err := os.WriteFile(filePath, []byte(ruleContent), 0666); err != nil {	1✔
139	log.Log.Error(err, "addUdevRule(): fail to write file", "path", filePath)	×
140	return err	×
141	}	×
142	return nil	1✔
143	}
144
145	func (u *udev) removeUdevRule(pfPciAddress, ruleName string) error {	1✔
146	log.Log.V(2).Info("removeUdevRule()", "device", pfPciAddress, "rule", ruleName)	1✔
147	rulePath := u.getRulePathForPF(ruleName, pfPciAddress)	1✔
148	err := os.Remove(rulePath)	1✔
149	if err != nil && !os.IsNotExist(err) {	1✔
150	log.Log.Error(err, "removeUdevRule(): fail to remove rule file", "path", rulePath)	×
151	return err	×
152	}	×
153	return nil	1✔
154	}
155
156	func (u *udev) getRuleFolderPath() string {	1✔
157	return filepath.Join(vars.FilesystemRoot, consts.UdevRulesFolder)	1✔
158	}	1✔
159
160	func (u *udev) getRulePathForPF(ruleName, pfPciAddress string) string {	1✔
161	return path.Join(u.getRuleFolderPath(), fmt.Sprintf("%s-%s.rules", ruleName, pfPciAddress))	1✔
162	}	1✔

k8snetworkplumbingwg / sriov-network-operator / 8467233545

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