Add collector to get pci and lsmod data

Author: brett060102

build/packaging/suseconnect-ng.spec

@@ -56,6 +56,7 @@ Requires:       ca-certificates
 %endif
 
 Requires:       coreutils
+Requires:       pciutils
 Requires:       zypper
 Requires:       util-linux
 Recommends:     systemd

cmd/suseconnect/suseconnect.go

@@ -117,6 +117,11 @@ func main() {
 	flag.BoolVar(&info, "i", false, "")
 
 	flag.Parse()
+	// when info set nothing sent to SCC,
+	// in that case we don't want to update
+	// contents of the data checksum files
+        util.UpdateLargeDataIDs = !info
+
 	if version {
 		fmt.Println(connect.GetShortenedVersion())
 		os.Exit(0)

internal/collectors/lsmod.go

@@ -0,0 +1,106 @@
+package collectors
+
+import (
+        "bufio"
+	"bytes"
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"sort"
+	"strings"
+
+	"github.com/SUSE/connect-ng/internal/util"
+)
+
+type KernMod struct {
+    KernModProfileID   string  // sha256 of KernModProfile
+    KernModProfile  []string     // sorted unique list of modules from lsmod
+}
+type LSMOD struct{}
+const KernModChecksumFile = "/etc/zypp/chksum-kernmoddata.txt"
+
+func getKernModChecksum (chkSumFilePath string) (string) {
+        // before system registration chkSumFilePath won't exist
+	// in that case just return emtpy string
+	if !util.FileExists(chkSumFilePath) {
+		return ""
+	}
+        // read value in from checksum file
+        content, err := localOsReadfile(chkSumFilePath)
+        // if read fails return empty string, should not happed
+	if err != nil {
+	        return ""
+        }
+	return string(content)
+
+}
+
+func putKernModChecksum (chkSumFilePath string, value string) (error) {
+	perms := os.FileMode(0644)
+	err := os.WriteFile(chkSumFilePath, []byte(value), perms)
+	return err
+}
+
+
+func (lsmod LSMOD) run(arch string) (Result, error) {
+        modInfo, err := util.Execute([]string{"lsmod"}, nil)
+	// Should not happen, but if command fails
+	// send nil to SCC to indicate that module data was unavailable.
+	if err != nil {
+		return Result{"KernModData": nil}, err
+	}
+	scanner := bufio.NewScanner(bytes.NewReader(modInfo))
+
+	// Iterate through each line get module name
+        modList := make(map[string]bool)
+	for scanner.Scan() {
+		module := strings.Fields(scanner.Text())[0]
+                // skip "Mudule" from the hearder line
+		if module != "Module" {
+		     modList[module] = true // update module list
+		}
+	}
+	// Check for any errors during scanning
+	if err := scanner.Err(); err != nil {
+		return Result{"KernModData": nil}, err
+	}
+
+        // run through mudual list removing duplicates
+        var sortedMods []string
+	for module := range modList {
+		sortedMods = append(sortedMods, module)
+	}
+
+        // sort the module list, , since the order does not matter
+	// and may change over system reboots.
+	sort.Strings(sortedMods)
+
+        // create comma seperated list of sorted modules
+	output := strings.Join(sortedMods,",")
+
+	byteOutput := []byte(output)
+	// get sha256 has a pci data
+	mkSha256 := sha256.New()
+	mkSha256.Write([]byte(byteOutput))
+	sha256 := mkSha256.Sum(nil)
+	modProfileId := hex.EncodeToString(sha256)
+
+        oldmodProfileId := getKernModChecksum (KernModChecksumFile)
+	if oldmodProfileId != modProfileId {
+                if util.UpdateLargeDataIDs {
+		        util.Debug.Print("updating: ", KernModChecksumFile)
+                        err = putPCIChecksum (KernModChecksumFile, modProfileId)
+	                if err != nil {
+		                return Result{"KernModData": nil}, err
+			}
+	        }
+                var dataBlob KernMod
+	        dataBlob.KernModProfileID = modProfileId
+	        dataBlob.KernModProfile = sortedMods
+	        return Result{"KernModData": dataBlob}, nil
+	} else {
+                var dataBlob KernMod
+	        dataBlob.KernModProfileID = modProfileId
+	        return Result{"KernModData": dataBlob}, nil
+	}
+}

internal/collectors/lsmod_test.go

@@ -0,0 +1,104 @@
+package collectors
+
+import (
+        "fmt"
+        "os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+
+func TestLSMODRunSuccess(t *testing.T) {
+	assert := assert.New(t)
+
+        var dataBlob KernMod
+	dataBlob.KernModProfileID = "0da8174a9f9c4a1f195d9af9804f24ba29e8431467e8203ae5663683292481e4"
+	dataBlob.KernModProfile = []string{"acpi_tad", "autofs4", "ccp", "dmi_sysfs", "efi_pstore", "hid_generic", "i2c_algo_bit", "i2c_piix4", "i2c_smbus", "input_leds", "ip_tables", "joydev", "k10temp", "lp", "mac_hid", "mc", "msr", "nfnetlink", "nvme", "nvme_core", "parport", "parport_pc", "ppdev", "psmouse", "r8169", "rc_core", "realtek", "sch_fq_codel", "snd_pci_acp3x", "snd_soc_acpi", "soundcore", "usbhid", "x_tables"}
+
+        kernModTestData :=`rc_core                73728  1 cec
+snd_soc_acpi           16384  3 snd_sof_amd_acp,snd_acp_config,snd_pci_ps
+i2c_piix4              32768  0
+mc                     81920  5 videodev,snd_usb_audio,videobuf2_v4l2,uvcvideo,videobuf2_common
+k10temp                16384  0
+i2c_algo_bit           16384  1 amdgpu
+i2c_smbus              20480  1 i2c_piix4
+soundcore              16384  1 snd
+ccp                   155648  1 kvm_amd
+snd_pci_acp3x          16384  0
+input_leds             12288  0
+joydev                 32768  0
+acpi_tad               20480  0
+mac_hid                12288  0
+sch_fq_codel           24576  4
+msr                    12288  0
+parport_pc             53248  0
+ppdev                  24576  0
+lp                     28672  0
+parport                73728  3 parport_pc,lp,ppdev
+efi_pstore             12288  0
+nfnetlink              20480  5 nft_compat,nf_tables,ip_set
+dmi_sysfs              24576  0
+ip_tables              32768  0
+x_tables               65536  9 xt_conntrack,nft_compat,xt_tcpudp,xt_addrtype,xt_CHECKSUM,xt_set,ipt_REJECT,ip_tables,xt_MASQUERADE
+autofs4                57344  2
+hid_generic            12288  0
+usbhid                 77824  0
+nvme                   61440  2
+psmouse               217088  0
+r8169                 126976  0
+nvme_core             225280  3 nvme
+realtek                49152  2
+`
+
+        mockUtilExecute(kernModTestData, nil)
+	expected := Result{"KernModData": dataBlob}
+
+	collector := LSMOD{}
+	result, err := collector.run(ARCHITECTURE_X86_64)
+
+	assert.Equal(expected, result)
+	assert.Nil(err)
+}
+
+func TestLSMODRunFail(t *testing.T) {
+	assert := assert.New(t)
+
+        mockUtilExecute("", fmt.Errorf("forced error"))
+	expected := Result{"KernModData": nil}
+
+	collector := LSMOD{}
+	result, err := collector.run(ARCHITECTURE_X86_64)
+
+	assert.Equal(expected, result)
+	assert.ErrorContains(err, "forced error")
+}
+
+func TestKernModChkSum(t *testing.T) {
+	assert := assert.New(t)
+
+        err := putKernModChecksum("/tmp/testPutCheckSum", "testthis")
+	assert.Nil(err)
+	content, err1 := os.ReadFile("/tmp/testPutCheckSum")
+	assert.Nil(err1)
+	assert.Equal("testthis", string(content))
+
+}
+
+func TestGetKernModChkSum(t *testing.T) {
+	assert := assert.New(t)
+        mockUtilFileExists(true)
+	KernModChecksumFile := "/etc/zypp/chksum-kernmoddata.txt"
+        mockLocalOsReadfile(t, KernModChecksumFile , "TestThis")
+
+	tstChkSum := getKernModChecksum(KernModChecksumFile)
+	assert.Equal("TestThis", tstChkSum)
+}
+
+func TestGetKernModChkSumNoFile(t *testing.T) {
+	assert := assert.New(t)
+        mockUtilFileExists(false)
+
+	tstChkSum := getKernModChecksum("/etc/zypp/chksum-kernmoddata.txt")
+	assert.Equal("", tstChkSum)
+}

internal/collectors/pci.go

@@ -0,0 +1,76 @@
+package collectors
+
+import (
+        "crypto/sha256"
+	"encoding/hex"
+        "os"
+	"github.com/SUSE/connect-ng/internal/util"
+)
+
+//var InfoOnly bool // indicated that -i/--info was used
+const PCIChecksumFile = "/etc/zypp/chksum-pcidata.txt"
+
+type PciProfile struct {
+    PCIProfileID   string  // sha256 of PCIProfile
+    PCIProfile string      // output from "lspci -s .0"
+}
+type PCI struct{}
+
+func getPCIChecksum (chkSumFilePath string) (string) {
+        // before system registration chkSumFilePath won't exist
+	// in that case just return emtpy string
+	if !util.FileExists(chkSumFilePath) {
+	        return ""
+	}
+
+        // read value in from checksum file
+        content, err := localOsReadfile(chkSumFilePath)
+        // if read fails return empty string, should not happed
+	if err != nil {
+	        return ""
+        }
+	return string(content)
+}
+
+
+func putPCIChecksum (chkSumFilePath string, value string) (error) {
+	perms := os.FileMode(0644)
+	err := os.WriteFile(chkSumFilePath, []byte(value), perms)
+	return err
+}
+
+
+func (pci PCI) run(arch string) (Result, error) {
+        output, err := util.Execute([]string{"lspci", "-s", ".0"}, nil)
+	// Some systems may not have lspci command, so
+	// if the execute fails,
+	// send nil to SCC to indicate that PCI data was unavailable.
+	if err != nil {
+		return Result{"PCIData": nil}, err
+	}
+	stringOutput := string(output)
+	// get sha256 has a pci data
+	mkSha256 := sha256.New()
+	mkSha256.Write([]byte(output))
+	sha256 := mkSha256.Sum(nil)
+	hwIndex := hex.EncodeToString(sha256)
+
+        oldHwIndex := getPCIChecksum (PCIChecksumFile)
+	if oldHwIndex != hwIndex {
+                if util.UpdateLargeDataIDs {
+                        util.Debug.Print("updating: ", PCIChecksumFile)
+	                err = putPCIChecksum (PCIChecksumFile, hwIndex)
+		        if err != nil {
+		                return Result{"PCIData": nil}, err
+			}
+		}
+                var dataBlob  PciProfile
+	        dataBlob.PCIProfileID = hwIndex
+	        dataBlob.PCIProfile = stringOutput
+	        return Result{"PCIData": dataBlob}, nil
+	} else {
+                var dataBlob  PciProfile
+	        dataBlob.PCIProfileID = hwIndex
+	        return Result{"PCIData": dataBlob}, nil
+	}
+}

internal/collectors/pci_test.go

@@ -0,0 +1,69 @@
+package collectors
+
+import (
+        "fmt"
+        "os"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+
+func TestPCIRunSuccess(t *testing.T) {
+	assert := assert.New(t)
+
+        var dataBlob PciProfile
+	dataBlob.PCIProfileID = "de5b2af84042cbe8298be6864362a99bae3e087fea4efcdad9e33f58fa323185"
+	dataBlob.PCIProfile = "00:00.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Root Complex (rev 01)\n00:01.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Dummy Host Bridge (rev 01)\n00:02.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Dummy Host Bridge (rev 01)\n00:03.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Dummy Host Bridge (rev 01)\n00:04.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Dummy Host Bridge (rev 01)\n00:08.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Family 17h-19h PCIe Dummy Host Bridge (rev 01)\n00:14.0 SMBus: Advanced Micro Devices, Inc. [AMD] FCH SMBus Controller (rev 71)\n00:18.0 Host bridge: Advanced Micro Devices, Inc. [AMD] Rembrandt Data Fabric: Device 18h; Function 0\n01:00.0 Non-Volatile memory controller: Micron/Crucial Technology Device 5426 (rev 01)\n02:00.0 Network controller: Intel Corporation Wi-Fi 6 AX200 (rev 1a)\n03:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411 PCI Express Gigabit Ethernet Controller (rev 15)\n04:00.0 Ethernet controller: Realtek Semiconductor Co., Ltd. RTL8111/8168/8211/8411 PCI Express Gigabit Ethernet Controller (rev 15)\n05:00.0 VGA compatible controller: Advanced Micro Devices, Inc. [AMD/ATI] Rembrandt [Radeon 680M] (rev c7)\n06:00.0 USB controller: Advanced Micro Devices, Inc. [AMD] Rembrandt USB4 XHCI controller #8"
+
+        mockUtilExecute(dataBlob.PCIProfile, nil)
+	expected := Result{"PCIData": dataBlob}
+
+	collector := PCI{}
+	result, err := collector.run(ARCHITECTURE_X86_64)
+
+	assert.Equal(expected, result)
+	assert.Nil(err)
+}
+
+func TestPCIRunFail(t *testing.T) {
+	assert := assert.New(t)
+
+        mockUtilExecute("", fmt.Errorf("forced error"))
+	expected := Result{"PCIData": nil}
+
+	collector := PCI{}
+	result, err := collector.run(ARCHITECTURE_X86_64)
+
+	assert.Equal(expected, result)
+	assert.ErrorContains(err, "forced error")
+}
+
+
+func TestPutPCIChkSum(t *testing.T) {
+	assert := assert.New(t)
+
+        err := putPCIChecksum("/tmp/testPutCheckSum", "testthis")
+	assert.Nil(err)
+	content, err1 := os.ReadFile("/tmp/testPutCheckSum")
+	assert.Nil(err1)
+	assert.Equal("testthis", string(content))
+
+}
+
+func TestGetPCIChkSum(t *testing.T) {
+	assert := assert.New(t)
+        mockUtilFileExists(true)
+        mockLocalOsReadfile(t, "/etc/zypp/chksum-pcidata.txt", "TestThis")
+
+	tstChkSum := getPCIChecksum("/etc/zypp/chksum-pcidata.txt")
+	assert.Equal("TestThis", tstChkSum)
+}
+
+func TestGetPCIChkSumNoFile(t *testing.T) {
+	assert := assert.New(t)
+        mockUtilFileExists(false)
+
+	tstChkSum := getPCIChecksum("/etc/zypp/chksum-pcidata.txt")
+	assert.Equal("", tstChkSum)
+}

internal/connect/api.go

@@ -271,6 +271,8 @@ var mandatoryCollectors = []collectors.Collector{
 	collectors.CloudProvider{},
 	collectors.Architecture{},
 	collectors.ContainerRuntime{},
+	collectors.PCI{},
+	collectors.LSMOD{},
 
 	// Optional collectors
 	collectors.Uname{},

internal/util/system.go

@@ -27,6 +27,7 @@ const (
 )
 
 var systemEcho bool
+var UpdateLargeDataIDs bool // set if -i/--info was used
 
 // SetSystemEcho toggles piping of executed command's outputs to stdout/stderr
 // returns true if it was enabled before, false otherwise