From d6e7a58ac9464a7a6936986142ebc83cdd8a350a Mon Sep 17 00:00:00 2001 From: David Gibson Date: Tue, 23 Jun 2020 15:17:51 +1000 Subject: [PATCH 1/4] qemu: Clarify test with bad machine type The last stanza of TestQemuAmd64Bridges is rather odd. It tries to create a qemu instance with a machine type of (QemuQ35 + QemuPC), or in other words "q35pc", which isn't a thing. What it's asserting about this is that the returned bridges list is empty despite asking for bridges, so it looks like what this is really trying to test is for sane behaviour when given a bad machine type. So, split this out into a separate test, and make it explicit for clarity. Signed-off-by: David Gibson --- src/runtime/virtcontainers/qemu_amd64_test.go | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/runtime/virtcontainers/qemu_amd64_test.go b/src/runtime/virtcontainers/qemu_amd64_test.go index 2032e1f01d..4c5e0d1bd7 100644 --- a/src/runtime/virtcontainers/qemu_amd64_test.go +++ b/src/runtime/virtcontainers/qemu_amd64_test.go @@ -27,6 +27,15 @@ func newTestQemu(machineType string) qemuArch { return newQemuArch(config) } +func TestQemuAmd64BadMachineType(t *testing.T) { + assert := assert.New(t) + + amd64 := newTestQemu("no-such-machine-type") + amd64.bridges(5) + bridges := amd64.getBridges() + assert.Nil(bridges) +} + func TestQemuAmd64Capabilities(t *testing.T) { assert := assert.New(t) @@ -66,11 +75,6 @@ func TestQemuAmd64Bridges(t *testing.T) { assert.Equal(id, b.ID) assert.NotNil(b.Devices) } - - amd64 = newTestQemu(QemuQ35 + QemuPC) - amd64.bridges(uint32(len)) - bridges = amd64.getBridges() - assert.Nil(bridges) } func TestQemuAmd64CPUModel(t *testing.T) { From 97a02131c69d8e70567ff43bbcc5489a1e30751a Mon Sep 17 00:00:00 2001 From: David Gibson Date: Tue, 23 Jun 2020 00:38:10 +1000 Subject: [PATCH 2/4] qemu: Detect and fail a bad machine type earlier Currently, newQemuArch() doesn't return an error. So, if passed an invalid machine type, it will return a technically valid, but unusable qemuArch object, which will probably fail with other errors shortly down the track. Change this, to more cleanly fail the newQemuArch itself, letting us detect a bad machine type earlier. Signed-off-by: David Gibson --- src/runtime/virtcontainers/qemu.go | 10 ++++- src/runtime/virtcontainers/qemu_amd64.go | 16 +++++++- src/runtime/virtcontainers/qemu_amd64_test.go | 41 +++++++++++-------- src/runtime/virtcontainers/qemu_arm64.go | 8 +++- src/runtime/virtcontainers/qemu_arm64_test.go | 12 +++--- src/runtime/virtcontainers/qemu_ppc64le.go | 8 +++- .../virtcontainers/qemu_ppc64le_test.go | 10 +++-- src/runtime/virtcontainers/qemu_s390x.go | 8 +++- src/runtime/virtcontainers/qemu_s390x_test.go | 10 +++-- 9 files changed, 82 insertions(+), 41 deletions(-) diff --git a/src/runtime/virtcontainers/qemu.go b/src/runtime/virtcontainers/qemu.go index fca0e57dee..6e7922c545 100644 --- a/src/runtime/virtcontainers/qemu.go +++ b/src/runtime/virtcontainers/qemu.go @@ -238,7 +238,10 @@ func (q *qemu) setup(id string, hypervisorConfig *HypervisorConfig) error { q.id = id q.config = *hypervisorConfig - q.arch = newQemuArch(q.config) + q.arch, err = newQemuArch(q.config) + if err != nil { + return err + } initrdPath, err := q.config.InitrdAssetPath() if err != nil { @@ -2172,7 +2175,10 @@ func (q *qemu) fromGrpc(ctx context.Context, hypervisorConfig *HypervisorConfig, q.qmpMonitorCh.path = qp.QmpChannelpath q.qemuConfig.Ctx = ctx q.state = qp.State - q.arch = newQemuArch(q.config) + q.arch, err = newQemuArch(q.config) + if err != nil { + return err + } q.ctx = ctx q.nvdimmCount = qp.NvdimmCount diff --git a/src/runtime/virtcontainers/qemu_amd64.go b/src/runtime/virtcontainers/qemu_amd64.go index 2da6073650..28d46dd108 100644 --- a/src/runtime/virtcontainers/qemu_amd64.go +++ b/src/runtime/virtcontainers/qemu_amd64.go @@ -6,6 +6,7 @@ package virtcontainers import ( + "fmt" "time" "github.com/kata-containers/kata-containers/src/runtime/virtcontainers/types" @@ -77,12 +78,23 @@ func MaxQemuVCPUs() uint32 { return uint32(240) } -func newQemuArch(config HypervisorConfig) qemuArch { +func newQemuArch(config HypervisorConfig) (qemuArch, error) { machineType := config.HypervisorMachineType if machineType == "" { machineType = defaultQemuMachineType } + var mp *govmmQemu.Machine + for _, m := range supportedQemuMachines { + if m.Type == machineType { + mp = &m + break + } + } + if mp == nil { + return nil, fmt.Errorf("unrecognised machinetype: %v", machineType) + } + factory := false if config.BootToBeTemplate || config.BootFromTemplate { factory = true @@ -124,7 +136,7 @@ func newQemuArch(config HypervisorConfig) qemuArch { q.handleImagePath(config) - return q + return q, nil } func (q *qemuAmd64) capabilities() types.Capabilities { diff --git a/src/runtime/virtcontainers/qemu_amd64_test.go b/src/runtime/virtcontainers/qemu_amd64_test.go index 4c5e0d1bd7..d6e5b18159 100644 --- a/src/runtime/virtcontainers/qemu_amd64_test.go +++ b/src/runtime/virtcontainers/qemu_amd64_test.go @@ -22,35 +22,36 @@ func qemuConfig(machineType string) HypervisorConfig { } } -func newTestQemu(machineType string) qemuArch { +func newTestQemu(assert *assert.Assertions, machineType string) qemuArch { config := qemuConfig(machineType) - return newQemuArch(config) + arch, err := newQemuArch(config) + assert.NoError(err) + return arch } func TestQemuAmd64BadMachineType(t *testing.T) { assert := assert.New(t) - amd64 := newTestQemu("no-such-machine-type") - amd64.bridges(5) - bridges := amd64.getBridges() - assert.Nil(bridges) + config := qemuConfig("no-such-machine-type") + _, err := newQemuArch(config) + assert.Error(err) } func TestQemuAmd64Capabilities(t *testing.T) { assert := assert.New(t) - amd64 := newTestQemu(QemuPC) + amd64 := newTestQemu(assert, QemuPC) caps := amd64.capabilities() assert.True(caps.IsBlockDeviceHotplugSupported()) - amd64 = newTestQemu(QemuQ35) + amd64 = newTestQemu(assert, QemuQ35) caps = amd64.capabilities() assert.True(caps.IsBlockDeviceHotplugSupported()) } func TestQemuAmd64Bridges(t *testing.T) { assert := assert.New(t) - amd64 := newTestQemu(QemuPC) + amd64 := newTestQemu(assert, QemuPC) len := 5 amd64.bridges(uint32(len)) @@ -64,7 +65,7 @@ func TestQemuAmd64Bridges(t *testing.T) { assert.NotNil(b.Devices) } - amd64 = newTestQemu(QemuQ35) + amd64 = newTestQemu(assert, QemuQ35) amd64.bridges(uint32(len)) bridges = amd64.getBridges() assert.Len(bridges, len) @@ -79,7 +80,7 @@ func TestQemuAmd64Bridges(t *testing.T) { func TestQemuAmd64CPUModel(t *testing.T) { assert := assert.New(t) - amd64 := newTestQemu(QemuPC) + amd64 := newTestQemu(assert, QemuPC) expectedOut := defaultCPUModel model := amd64.cpuModel() @@ -101,7 +102,7 @@ func TestQemuAmd64CPUModel(t *testing.T) { func TestQemuAmd64MemoryTopology(t *testing.T) { assert := assert.New(t) - amd64 := newTestQemu(QemuPC) + amd64 := newTestQemu(assert, QemuPC) memoryOffset := 1024 hostMem := uint64(100) @@ -135,7 +136,8 @@ func TestQemuAmd64AppendImage(t *testing.T) { cfg := qemuConfig(QemuPC) cfg.ImagePath = f.Name() cfg.DisableImageNvdimm = false - amd64 := newQemuArch(cfg) + amd64, err := newQemuArch(cfg) + assert.NoError(err) for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { assert.Contains(m.Options, qemuNvdimmOption) } @@ -159,7 +161,8 @@ func TestQemuAmd64AppendImage(t *testing.T) { assert.Equal(len(supportedQemuMachines), copy(supportedQemuMachines, machinesCopy)) cfg.DisableImageNvdimm = true - amd64 = newQemuArch(cfg) + amd64, err = newQemuArch(cfg) + assert.NoError(err) for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { assert.NotContains(m.Options, qemuNvdimmOption) } @@ -185,7 +188,7 @@ func TestQemuAmd64AppendBridges(t *testing.T) { assert := assert.New(t) // check PC - amd64 := newTestQemu(QemuPC) + amd64 := newTestQemu(assert, QemuPC) amd64.bridges(1) bridges := amd64.getBridges() @@ -208,7 +211,7 @@ func TestQemuAmd64AppendBridges(t *testing.T) { assert.Equal(expectedOut, devices) // Check Q35 - amd64 = newTestQemu(QemuQ35) + amd64 = newTestQemu(assert, QemuQ35) amd64.bridges(1) bridges = amd64.getBridges() @@ -237,7 +240,8 @@ func TestQemuAmd64WithInitrd(t *testing.T) { cfg := qemuConfig(QemuPC) cfg.InitrdPath = "dummy-initrd" - amd64 := newQemuArch(cfg) + amd64, err := newQemuArch(cfg) + assert.NoError(err) for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { assert.NotContains(m.Options, qemuNvdimmOption) @@ -249,7 +253,8 @@ func TestQemuAmd64Iommu(t *testing.T) { config := qemuConfig(QemuQ35) config.IOMMU = true - qemu := newQemuArch(config) + qemu, err := newQemuArch(config) + assert.NoError(err) p := qemu.kernelParameters(false) assert.Contains(p, Param{"intel_iommu", "on"}) diff --git a/src/runtime/virtcontainers/qemu_arm64.go b/src/runtime/virtcontainers/qemu_arm64.go index 9d1964c1c6..6526c7398c 100644 --- a/src/runtime/virtcontainers/qemu_arm64.go +++ b/src/runtime/virtcontainers/qemu_arm64.go @@ -125,12 +125,16 @@ func MaxQemuVCPUs() uint32 { return uint32(runtime.NumCPU()) } -func newQemuArch(config HypervisorConfig) qemuArch { +func newQemuArch(config HypervisorConfig) (qemuArch, error) { machineType := config.HypervisorMachineType if machineType == "" { machineType = defaultQemuMachineType } + if machineType != defaultQemuMachineType { + return nil, fmt.Errorf("unrecognised machinetype: %v", machineType) + } + q := &qemuArm64{ qemuArchBase{ machineType: machineType, @@ -146,7 +150,7 @@ func newQemuArch(config HypervisorConfig) qemuArch { q.handleImagePath(config) - return q + return q, nil } func (q *qemuArm64) bridges(number uint32) { diff --git a/src/runtime/virtcontainers/qemu_arm64_test.go b/src/runtime/virtcontainers/qemu_arm64_test.go index 4035115829..e5a36707e8 100644 --- a/src/runtime/virtcontainers/qemu_arm64_test.go +++ b/src/runtime/virtcontainers/qemu_arm64_test.go @@ -23,14 +23,16 @@ func qemuConfig(machineType string) HypervisorConfig { } } -func newTestQemu(machineType string) qemuArch { +func newTestQemu(assert *assert.Assertions, machineType string) qemuArch { config := qemuConfig(machineType) - return newQemuArch(config) + arch, err := newQemuArch(config) + assert.NoError(err) + return arch } func TestQemuArm64CPUModel(t *testing.T) { assert := assert.New(t) - arm64 := newTestQemu(QemuVirt) + arm64 := newTestQemu(assert, QemuVirt) expectedOut := defaultCPUModel model := arm64.cpuModel() @@ -39,7 +41,7 @@ func TestQemuArm64CPUModel(t *testing.T) { func TestQemuArm64MemoryTopology(t *testing.T) { assert := assert.New(t) - arm64 := newTestQemu(QemuVirt) + arm64 := newTestQemu(assert, QemuVirt) hostMem := uint64(4096) mem := uint64(1024) @@ -107,7 +109,7 @@ func TestQemuArm64AppendBridges(t *testing.T) { var devices []govmmQemu.Device assert := assert.New(t) - arm64 := newTestQemu(QemuVirt) + arm64 := newTestQemu(assert, QemuVirt) arm64.bridges(1) bridges := arm64.getBridges() diff --git a/src/runtime/virtcontainers/qemu_ppc64le.go b/src/runtime/virtcontainers/qemu_ppc64le.go index f97c07d368..45cf0f7389 100644 --- a/src/runtime/virtcontainers/qemu_ppc64le.go +++ b/src/runtime/virtcontainers/qemu_ppc64le.go @@ -57,12 +57,16 @@ func MaxQemuVCPUs() uint32 { return uint32(128) } -func newQemuArch(config HypervisorConfig) qemuArch { +func newQemuArch(config HypervisorConfig) (qemuArch, error) { machineType := config.HypervisorMachineType if machineType == "" { machineType = defaultQemuMachineType } + if machineType != defaultQemuMachineType { + return nil, fmt.Errorf("unrecognised machinetype: %v", machineType) + } + q := &qemuPPC64le{ qemuArchBase{ machineType: machineType, @@ -79,7 +83,7 @@ func newQemuArch(config HypervisorConfig) qemuArch { q.memoryOffset = config.MemOffset - return q + return q, nil } func (q *qemuPPC64le) capabilities() types.Capabilities { diff --git a/src/runtime/virtcontainers/qemu_ppc64le_test.go b/src/runtime/virtcontainers/qemu_ppc64le_test.go index 6e2c7f08fd..f48e2bae0b 100644 --- a/src/runtime/virtcontainers/qemu_ppc64le_test.go +++ b/src/runtime/virtcontainers/qemu_ppc64le_test.go @@ -13,16 +13,18 @@ import ( "github.com/stretchr/testify/assert" ) -func newTestQemu(machineType string) qemuArch { +func newTestQemu(assert *assert.Assertions, machineType string) qemuArch { config := HypervisorConfig{ HypervisorMachineType: machineType, } - return newQemuArch(config) + arch, err := newQemuArch(config) + assert.NoError(err) + return arch } func TestQemuPPC64leCPUModel(t *testing.T) { assert := assert.New(t) - ppc64le := newTestQemu(QemuPseries) + ppc64le := newTestQemu(assert, QemuPseries) expectedOut := defaultCPUModel model := ppc64le.cpuModel() @@ -31,7 +33,7 @@ func TestQemuPPC64leCPUModel(t *testing.T) { func TestQemuPPC64leMemoryTopology(t *testing.T) { assert := assert.New(t) - ppc64le := newTestQemu(QemuPseries) + ppc64le := newTestQemu(assert, QemuPseries) memoryOffset := 1024 hostMem := uint64(1024) diff --git a/src/runtime/virtcontainers/qemu_s390x.go b/src/runtime/virtcontainers/qemu_s390x.go index d6e449ff38..d9e8c38145 100644 --- a/src/runtime/virtcontainers/qemu_s390x.go +++ b/src/runtime/virtcontainers/qemu_s390x.go @@ -55,12 +55,16 @@ func MaxQemuVCPUs() uint32 { return uint32(248) } -func newQemuArch(config HypervisorConfig) qemuArch { +func newQemuArch(config HypervisorConfig) (qemuArch, error) { machineType := config.HypervisorMachineType if machineType == "" { machineType = defaultQemuMachineType } + if machineType != defaultQemuMachineType { + return nil, fmt.Errorf("unrecognised machinetype: %v", machineType) + } + q := &qemuS390x{ qemuArchBase{ machineType: machineType, @@ -81,7 +85,7 @@ func newQemuArch(config HypervisorConfig) qemuArch { q.kernelParamsDebug = append(q.kernelParamsDebug, kernelParamsSystemdDebug...) } - return q + return q, nil } func (q *qemuS390x) bridges(number uint32) { diff --git a/src/runtime/virtcontainers/qemu_s390x_test.go b/src/runtime/virtcontainers/qemu_s390x_test.go index 17c20276a4..4cdeeb245e 100644 --- a/src/runtime/virtcontainers/qemu_s390x_test.go +++ b/src/runtime/virtcontainers/qemu_s390x_test.go @@ -14,16 +14,18 @@ import ( "github.com/stretchr/testify/assert" ) -func newTestQemu(machineType string) qemuArch { +func newTestQemu(assert *assert.Assertions, machineType string) qemuArch { config := HypervisorConfig{ HypervisorMachineType: machineType, } - return newQemuArch(config) + arch, err := newQemuArch(config) + assert.NoError(err) + return arch } func TestQemuS390xCPUModel(t *testing.T) { assert := assert.New(t) - s390x := newTestQemu(QemuCCWVirtio) + s390x := newTestQemu(assert, QemuCCWVirtio) expectedOut := defaultCPUModel model := s390x.cpuModel() @@ -37,7 +39,7 @@ func TestQemuS390xCPUModel(t *testing.T) { func TestQemuS390xMemoryTopology(t *testing.T) { assert := assert.New(t) - s390x := newTestQemu(QemuCCWVirtio) + s390x := newTestQemu(assert, QemuCCWVirtio) hostMem := uint64(1024) mem := uint64(120) From 5dffffd432f587bd9ac5e05bf573809ba5c5eb72 Mon Sep 17 00:00:00 2001 From: David Gibson Date: Mon, 15 Jun 2020 20:29:33 +1000 Subject: [PATCH 3/4] qemu: Remove useless table from qemuArchBase The supportedQemuMachines array in qemuArchBase has a list of all the qemu machine types supported for the architecture, with the options for each. But, the machineType field already tells us which of the machine types we're actually using, and that's the only entry we actually care about. So, drop the table, and just have a single value with the machine type we're actually using. As a bonus that means the machine() method can no longer fail, so no longer needs an error return. Signed-off-by: David Gibson --- src/runtime/virtcontainers/qemu.go | 10 +---- src/runtime/virtcontainers/qemu_amd64.go | 23 ++++------- src/runtime/virtcontainers/qemu_amd64_test.go | 16 ++------ src/runtime/virtcontainers/qemu_arch_base.go | 35 ++++++----------- .../virtcontainers/qemu_arch_base_test.go | 39 ++++++------------- src/runtime/virtcontainers/qemu_arm64.go | 15 +++---- src/runtime/virtcontainers/qemu_arm64_test.go | 8 +--- src/runtime/virtcontainers/qemu_ppc64le.go | 17 ++++---- src/runtime/virtcontainers/qemu_s390x.go | 15 +++---- src/runtime/virtcontainers/qemu_test.go | 7 +++- 10 files changed, 64 insertions(+), 121 deletions(-) diff --git a/src/runtime/virtcontainers/qemu.go b/src/runtime/virtcontainers/qemu.go index 6e7922c545..31865b3b50 100644 --- a/src/runtime/virtcontainers/qemu.go +++ b/src/runtime/virtcontainers/qemu.go @@ -335,10 +335,7 @@ func (q *qemu) qmpSocketPath(id string) (string, error) { } func (q *qemu) getQemuMachine() (govmmQemu.Machine, error) { - machine, err := q.arch.machine() - if err != nil { - return govmmQemu.Machine{}, err - } + machine := q.arch.machine() accelerators := q.config.MachineAccelerators if accelerators != "" { @@ -1542,10 +1539,7 @@ func (q *qemu) hotplugAddCPUs(amount uint32) (uint32, error) { return 0, fmt.Errorf("failed to query hotpluggable CPUs: %v", err) } - machine, err := q.arch.machine() - if err != nil { - return 0, fmt.Errorf("failed to query machine type: %v", err) - } + machine := q.arch.machine() var hotpluggedVCPUs uint32 for _, hc := range hotpluggableVCPUs { diff --git a/src/runtime/virtcontainers/qemu_amd64.go b/src/runtime/virtcontainers/qemu_amd64.go index 28d46dd108..92c056de60 100644 --- a/src/runtime/virtcontainers/qemu_amd64.go +++ b/src/runtime/virtcontainers/qemu_amd64.go @@ -100,7 +100,6 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { factory = true } - var qemuMachines = supportedQemuMachines if config.IOMMU { var q35QemuIOMMUOptions = "accel=kvm,kernel_irqchip=split" @@ -109,22 +108,16 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { kernelParams = append(kernelParams, Param{"iommu", "pt"}) - for i, m := range qemuMachines { - if m.Type == QemuQ35 { - qemuMachines[i].Options = q35QemuIOMMUOptions - } + if mp.Type == QemuQ35 { + mp.Options = q35QemuIOMMUOptions } - } else { - kernelParams = append(kernelParams, - Param{"iommu", "off"}) } q := &qemuAmd64{ qemuArchBase: qemuArchBase{ - machineType: machineType, + qemuMachine: *mp, memoryOffset: config.MemOffset, qemuPaths: qemuPaths, - supportedQemuMachines: qemuMachines, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, @@ -142,9 +135,9 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { func (q *qemuAmd64) capabilities() types.Capabilities { var caps types.Capabilities - if q.machineType == QemuPC || - q.machineType == QemuQ35 || - q.machineType == QemuVirt { + if q.qemuMachine.Type == QemuPC || + q.qemuMachine.Type == QemuQ35 || + q.qemuMachine.Type == QemuVirt { caps.SetBlockDeviceHotplugSupport() } @@ -155,7 +148,7 @@ func (q *qemuAmd64) capabilities() types.Capabilities { } func (q *qemuAmd64) bridges(number uint32) { - q.Bridges = genericBridges(number, q.machineType) + q.Bridges = genericBridges(number, q.qemuMachine.Type) } func (q *qemuAmd64) cpuModel() string { @@ -187,5 +180,5 @@ func (q *qemuAmd64) appendImage(devices []govmmQemu.Device, path string) ([]govm // appendBridges appends to devices the given bridges func (q *qemuAmd64) appendBridges(devices []govmmQemu.Device) []govmmQemu.Device { - return genericAppendBridges(devices, q.Bridges, q.machineType) + return genericAppendBridges(devices, q.Bridges, q.qemuMachine.Type) } diff --git a/src/runtime/virtcontainers/qemu_amd64_test.go b/src/runtime/virtcontainers/qemu_amd64_test.go index d6e5b18159..b2d0b0cfc3 100644 --- a/src/runtime/virtcontainers/qemu_amd64_test.go +++ b/src/runtime/virtcontainers/qemu_amd64_test.go @@ -138,9 +138,7 @@ func TestQemuAmd64AppendImage(t *testing.T) { cfg.DisableImageNvdimm = false amd64, err := newQemuArch(cfg) assert.NoError(err) - for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { - assert.Contains(m.Options, qemuNvdimmOption) - } + assert.Contains(amd64.machine().Options, qemuNvdimmOption) expectedOut := []govmmQemu.Device{ govmmQemu.Object{ @@ -163,9 +161,7 @@ func TestQemuAmd64AppendImage(t *testing.T) { cfg.DisableImageNvdimm = true amd64, err = newQemuArch(cfg) assert.NoError(err) - for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { - assert.NotContains(m.Options, qemuNvdimmOption) - } + assert.NotContains(amd64.machine().Options, qemuNvdimmOption) found := false devices, err = amd64.appendImage(nil, f.Name()) @@ -243,9 +239,7 @@ func TestQemuAmd64WithInitrd(t *testing.T) { amd64, err := newQemuArch(cfg) assert.NoError(err) - for _, m := range amd64.(*qemuAmd64).supportedQemuMachines { - assert.NotContains(m.Options, qemuNvdimmOption) - } + assert.NotContains(amd64.machine().Options, qemuNvdimmOption) } func TestQemuAmd64Iommu(t *testing.T) { @@ -259,8 +253,6 @@ func TestQemuAmd64Iommu(t *testing.T) { p := qemu.kernelParameters(false) assert.Contains(p, Param{"intel_iommu", "on"}) - m, err := qemu.machine() - - assert.NoError(err) + m := qemu.machine() assert.Contains(m.Options, "kernel_irqchip=split") } diff --git a/src/runtime/virtcontainers/qemu_arch_base.go b/src/runtime/virtcontainers/qemu_arch_base.go index f790a36ee6..40fadc7c4c 100644 --- a/src/runtime/virtcontainers/qemu_arch_base.go +++ b/src/runtime/virtcontainers/qemu_arch_base.go @@ -38,7 +38,7 @@ type qemuArch interface { disableVhostNet() // machine returns the machine type - machine() (govmmQemu.Machine, error) + machine() govmmQemu.Machine // qemuPath returns the path to the QEMU binary qemuPath() (string, error) @@ -136,7 +136,7 @@ type qemuArch interface { } type qemuArchBase struct { - machineType string + qemuMachine govmmQemu.Machine memoryOffset uint32 nestedRun bool vhost bool @@ -144,7 +144,6 @@ type qemuArchBase struct { dax bool networkIndex int qemuPaths map[string]string - supportedQemuMachines []govmmQemu.Machine kernelParamsNonDebug []Param kernelParamsDebug []Param kernelParams []Param @@ -239,20 +238,14 @@ func (q *qemuArchBase) disableVhostNet() { q.vhost = false } -func (q *qemuArchBase) machine() (govmmQemu.Machine, error) { - for _, m := range q.supportedQemuMachines { - if m.Type == q.machineType { - return m, nil - } - } - - return govmmQemu.Machine{}, fmt.Errorf("unrecognised machine type: %v", q.machineType) +func (q *qemuArchBase) machine() govmmQemu.Machine { + return q.qemuMachine } func (q *qemuArchBase) qemuPath() (string, error) { - p, ok := q.qemuPaths[q.machineType] + p, ok := q.qemuPaths[q.qemuMachine.Type] if !ok { - return "", fmt.Errorf("Unknown machine type: %s", q.machineType) + return "", fmt.Errorf("Unknown machine type: %s", q.qemuMachine.Type) } return p, nil @@ -681,12 +674,9 @@ func (q *qemuArchBase) handleImagePath(config HypervisorConfig) { if config.ImagePath != "" { kernelRootParams := commonVirtioblkKernelRootParams if !q.disableNvdimm { - for i := range q.supportedQemuMachines { - q.supportedQemuMachines[i].Options = strings.Join([]string{ - q.supportedQemuMachines[i].Options, - qemuNvdimmOption, - }, ",") - } + q.qemuMachine.Options = strings.Join([]string{ + q.qemuMachine.Options, qemuNvdimmOption, + }, ",") if q.dax { kernelRootParams = commonNvdimmKernelRootParams } else { @@ -767,13 +757,12 @@ func (q *qemuArchBase) addBridge(b types.Bridge) { // appendPCIeRootPortDevice appends to devices the given pcie-root-port func (q *qemuArchBase) appendPCIeRootPortDevice(devices []govmmQemu.Device, number uint32) []govmmQemu.Device { - return genericAppendPCIeRootPort(devices, number, q.machineType) - + return genericAppendPCIeRootPort(devices, number, q.qemuMachine.Type) } // appendIOMMU appends a virtual IOMMU device func (q *qemuArchBase) appendIOMMU(devices []govmmQemu.Device) ([]govmmQemu.Device, error) { - switch q.machineType { + switch q.qemuMachine.Type { case QemuQ35: iommu := govmmQemu.IommuDev{ Intremap: true, @@ -784,6 +773,6 @@ func (q *qemuArchBase) appendIOMMU(devices []govmmQemu.Device) ([]govmmQemu.Devi devices = append(devices, iommu) return devices, nil default: - return devices, fmt.Errorf("Machine Type %s does not support vIOMMU", q.machineType) + return devices, fmt.Errorf("Machine Type %s does not support vIOMMU", q.qemuMachine.Type) } } diff --git a/src/runtime/virtcontainers/qemu_arch_base_test.go b/src/runtime/virtcontainers/qemu_arch_base_test.go index 8eacb085ac..417a32b2a4 100644 --- a/src/runtime/virtcontainers/qemu_arch_base_test.go +++ b/src/runtime/virtcontainers/qemu_arch_base_test.go @@ -23,12 +23,15 @@ import ( ) const ( - qemuArchBaseMachineType = "pc" qemuArchBaseQemuPath = "/usr/bin/qemu-system-x86_64" ) +var qemuArchBaseMachine = govmmQemu.Machine{ + Type: "pc", +} + var qemuArchBaseQemuPaths = map[string]string{ - qemuArchBaseMachineType: qemuArchBaseQemuPath, + qemuArchBaseMachine.Type: qemuArchBaseQemuPath, } var qemuArchBaseKernelParamsNonDebug = []Param{ @@ -47,18 +50,11 @@ var qemuArchBaseKernelParams = []Param{ {"rootfstype", "ext4"}, } -var qemuArchBaseSupportedQemuMachines = []govmmQemu.Machine{ - { - Type: qemuArchBaseMachineType, - }, -} - func newQemuArchBase() *qemuArchBase { return &qemuArchBase{ - machineType: qemuArchBaseMachineType, + qemuMachine: qemuArchBaseMachine, nestedRun: false, qemuPaths: qemuArchBaseQemuPaths, - supportedQemuMachines: qemuArchBaseSupportedQemuMachines, kernelParamsNonDebug: qemuArchBaseKernelParamsNonDebug, kernelParamsDebug: qemuArchBaseKernelParamsDebug, kernelParams: qemuArchBaseKernelParams, @@ -85,19 +81,8 @@ func TestQemuArchBaseMachine(t *testing.T) { assert := assert.New(t) qemuArchBase := newQemuArchBase() - m, err := qemuArchBase.machine() - assert.NoError(err) - assert.Equal(m.Type, qemuArchBaseMachineType) - - machines := []govmmQemu.Machine{ - { - Type: "bad", - }, - } - qemuArchBase.supportedQemuMachines = machines - m, err = qemuArchBase.machine() - assert.Error(err) - assert.Equal("", m.Type) + m := qemuArchBase.machine() + assert.Equal(m.Type, qemuArchBaseMachine.Type) } func TestQemuArchBaseQemuPath(t *testing.T) { @@ -166,7 +151,7 @@ func TestQemuAddDeviceToBridge(t *testing.T) { // addDeviceToBridge successfully q := newQemuArchBase() - q.machineType = QemuPC + q.qemuMachine.Type = QemuPC q.bridges(1) for i := uint32(1); i <= types.PCIBridgeMaxCapacity; i++ { @@ -181,7 +166,7 @@ func TestQemuAddDeviceToBridge(t *testing.T) { // addDeviceToBridge fails cause q.Bridges == 0 q = newQemuArchBase() - q.machineType = QemuPCLite + q.qemuMachine.Type = QemuPCLite q.bridges(0) _, _, err = q.addDeviceToBridge("qemu-bridge", types.PCI) if assert.Error(err) { @@ -581,11 +566,11 @@ func TestQemuArchBaseAppendIOMMU(t *testing.T) { }, } // Test IOMMU is not appended to PC machine type - qemuArchBase.machineType = QemuPC + qemuArchBase.qemuMachine.Type = QemuPC devices, err = qemuArchBase.appendIOMMU(devices) assert.Error(err) - qemuArchBase.machineType = QemuQ35 + qemuArchBase.qemuMachine.Type = QemuQ35 devices, err = qemuArchBase.appendIOMMU(devices) assert.NoError(err) assert.Equal(expectedOut, devices) diff --git a/src/runtime/virtcontainers/qemu_arm64.go b/src/runtime/virtcontainers/qemu_arm64.go index 6526c7398c..eaec0087cb 100644 --- a/src/runtime/virtcontainers/qemu_arm64.go +++ b/src/runtime/virtcontainers/qemu_arm64.go @@ -40,11 +40,9 @@ var kernelParams = []Param{ {"iommu.passthrough", "0"}, } -var supportedQemuMachines = []govmmQemu.Machine{ - { - Type: QemuVirt, - Options: defaultQemuMachineOptions, - }, +var supportedQemuMachine = govmmQemu.Machine { + Type: QemuVirt, + Options: defaultQemuMachineOptions, } // Logger returns a logrus logger appropriate for logging qemu-aarch64 messages @@ -137,10 +135,9 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuArm64{ qemuArchBase{ - machineType: machineType, + qemuMachine: supportedQemuMachine, memoryOffset: config.MemOffset, qemuPaths: qemuPaths, - supportedQemuMachines: supportedQemuMachines, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, @@ -154,12 +151,12 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { } func (q *qemuArm64) bridges(number uint32) { - q.Bridges = genericBridges(number, q.machineType) + q.Bridges = genericBridges(number, q.qemuMachine.Type) } // appendBridges appends to devices the given bridges func (q *qemuArm64) appendBridges(devices []govmmQemu.Device) []govmmQemu.Device { - return genericAppendBridges(devices, q.Bridges, q.machineType) + return genericAppendBridges(devices, q.Bridges, q.qemuMachine.Type) } func (q *qemuArm64) appendImage(devices []govmmQemu.Device, path string) ([]govmmQemu.Device, error) { diff --git a/src/runtime/virtcontainers/qemu_arm64_test.go b/src/runtime/virtcontainers/qemu_arm64_test.go index e5a36707e8..eeb6c2ed67 100644 --- a/src/runtime/virtcontainers/qemu_arm64_test.go +++ b/src/runtime/virtcontainers/qemu_arm64_test.go @@ -152,9 +152,7 @@ func TestQemuArm64AppendImage(t *testing.T) { cfg := qemuConfig(QemuVirt) cfg.ImagePath = f.Name() arm64 := newQemuArch(cfg) - for _, m := range arm64.(*qemuArm64).supportedQemuMachines { - assert.Contains(m.Options, qemuNvdimmOption) - } + assert.Contains(m.machine().Options, qemuNvdimmOption) expectedOut := []govmmQemu.Device{ govmmQemu.Object{ @@ -182,7 +180,5 @@ func TestQemuArm64WithInitrd(t *testing.T) { cfg.InitrdPath = "dummy-initrd" arm64 := newQemuArch(cfg) - for _, m := range arm64.(*qemuArm64).supportedQemuMachines { - assert.NotContains(m.Options, qemuNvdimmOption) - } + assert.NotContains(m.machine().Options, qemuNvdimmOption) } diff --git a/src/runtime/virtcontainers/qemu_ppc64le.go b/src/runtime/virtcontainers/qemu_ppc64le.go index 45cf0f7389..b6b22f0712 100644 --- a/src/runtime/virtcontainers/qemu_ppc64le.go +++ b/src/runtime/virtcontainers/qemu_ppc64le.go @@ -40,11 +40,9 @@ var kernelParams = []Param{ {"net.ifnames", "0"}, } -var supportedQemuMachines = []govmmQemu.Machine{ - { - Type: QemuPseries, - Options: defaultQemuMachineOptions, - }, +var supportedQemuMachine = govmmQemu.Machine { + Type: QemuPseries, + Options: defaultQemuMachineOptions, } // Logger returns a logrus logger appropriate for logging qemu messages @@ -69,10 +67,9 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuPPC64le{ qemuArchBase{ - machineType: machineType, + qemuMachine: supportedQemuMachine, memoryOffset: config.MemOffset, qemuPaths: qemuPaths, - supportedQemuMachines: supportedQemuMachines, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, @@ -90,7 +87,7 @@ func (q *qemuPPC64le) capabilities() types.Capabilities { var caps types.Capabilities // pseries machine type supports hotplugging drives - if q.machineType == QemuPseries { + if q.qemuMachine.Type == QemuPseries { caps.SetBlockDeviceHotplugSupport() } @@ -101,7 +98,7 @@ func (q *qemuPPC64le) capabilities() types.Capabilities { } func (q *qemuPPC64le) bridges(number uint32) { - q.Bridges = genericBridges(number, q.machineType) + q.Bridges = genericBridges(number, q.qemuMachine.Type) } func (q *qemuPPC64le) cpuModel() string { @@ -117,7 +114,7 @@ func (q *qemuPPC64le) memoryTopology(memoryMb, hostMemoryMb uint64, slots uint8) // appendBridges appends to devices the given bridges func (q *qemuPPC64le) appendBridges(devices []govmmQemu.Device) []govmmQemu.Device { - return genericAppendBridges(devices, q.Bridges, q.machineType) + return genericAppendBridges(devices, q.Bridges, q.qemuMachine.Type) } func (q *qemuPPC64le) appendIOMMU(devices []govmmQemu.Device) ([]govmmQemu.Device, error) { diff --git a/src/runtime/virtcontainers/qemu_s390x.go b/src/runtime/virtcontainers/qemu_s390x.go index d9e8c38145..4ad12a5e69 100644 --- a/src/runtime/virtcontainers/qemu_s390x.go +++ b/src/runtime/virtcontainers/qemu_s390x.go @@ -40,11 +40,9 @@ var kernelParams = []Param{ var ccwbridge = types.NewBridge(types.CCW, "", make(map[uint32]string, types.CCWBridgeMaxCapacity), 0) -var supportedQemuMachines = []govmmQemu.Machine{ - { - Type: QemuCCWVirtio, - Options: defaultQemuMachineOptions, - }, +var supportedQemuMachine = govmmQemu.Machine { + Type: QemuCCWVirtio, + Options: defaultQemuMachineOptions, } // MaxQemuVCPUs returns the maximum number of vCPUs supported @@ -67,10 +65,9 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuS390x{ qemuArchBase{ - machineType: machineType, + qemuMachine: supportedQemuMachine, memoryOffset: config.MemOffset, qemuPaths: qemuPaths, - supportedQemuMachines: supportedQemuMachines, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, @@ -89,7 +86,7 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { } func (q *qemuS390x) bridges(number uint32) { - q.Bridges = genericBridges(number, q.machineType) + q.Bridges = genericBridges(number, q.qemuMachine.Type) } // appendConsole appends a console to devices. @@ -230,7 +227,7 @@ func (q *qemuS390x) append9PVolume(devices []govmmQemu.Device, volume types.Volu // appendBridges appends to devices the given bridges func (q *qemuS390x) appendBridges(devices []govmmQemu.Device) []govmmQemu.Device { - return genericAppendBridges(devices, q.Bridges, q.machineType) + return genericAppendBridges(devices, q.Bridges, q.qemuMachine.Type) } func (q *qemuS390x) appendSCSIController(devices []govmmQemu.Device, enableIOThreads bool) ([]govmmQemu.Device, *govmmQemu.IOThread, error) { diff --git a/src/runtime/virtcontainers/qemu_test.go b/src/runtime/virtcontainers/qemu_test.go index 08d6f859fc..f1fe9924e6 100644 --- a/src/runtime/virtcontainers/qemu_test.go +++ b/src/runtime/virtcontainers/qemu_test.go @@ -342,7 +342,10 @@ func TestQemuQemuPath(t *testing.T) { qemuConfig := newQemuConfig() qemuConfig.HypervisorPath = expectedPath qkvm := &qemuArchBase{ - machineType: "pc", + qemuMachine: govmmQemu.Machine{ + Type: "pc", + Options: "", + }, qemuPaths: map[string]string{ "pc": expectedPath, }, @@ -371,7 +374,7 @@ func TestQemuQemuPath(t *testing.T) { assert.Equal(path, expectedPath) // bad machine type, arch should fail - qkvm.machineType = "rgb" + qkvm.qemuMachine.Type = "rgb" q.arch = qkvm path, err = q.qemuPath() assert.Error(err) From ea1d799f7961617dc7be7b70564444e66f6c890a Mon Sep 17 00:00:00 2001 From: David Gibson Date: Sat, 20 Jun 2020 20:04:49 +1000 Subject: [PATCH 4/4] qemu: Only one element of qemuPaths map is relevant The qemuPaths field in qemuArchBase maps from machine type to the default qemu path. But, by the time we construct it, we already know the machine type, so that entry ends up being the only one we care about. So, collapse the map into a single path. As a bonus, the qemuPath() method can no longer fail. Signed-off-by: David Gibson --- src/runtime/virtcontainers/qemu.go | 5 +---- src/runtime/virtcontainers/qemu_amd64.go | 2 +- src/runtime/virtcontainers/qemu_arch_base.go | 13 ++++--------- src/runtime/virtcontainers/qemu_arch_base_test.go | 13 ++----------- src/runtime/virtcontainers/qemu_arm64.go | 6 +----- src/runtime/virtcontainers/qemu_ppc64le.go | 6 +----- src/runtime/virtcontainers/qemu_s390x.go | 6 +----- src/runtime/virtcontainers/qemu_test.go | 11 +---------- 8 files changed, 12 insertions(+), 50 deletions(-) diff --git a/src/runtime/virtcontainers/qemu.go b/src/runtime/virtcontainers/qemu.go index 31865b3b50..3d21f953b4 100644 --- a/src/runtime/virtcontainers/qemu.go +++ b/src/runtime/virtcontainers/qemu.go @@ -199,10 +199,7 @@ func (q *qemu) qemuPath() (string, error) { } if p == "" { - p, err = q.arch.qemuPath() - if err != nil { - return "", err - } + p = q.arch.qemuPath() } if _, err = os.Stat(p); os.IsNotExist(err) { diff --git a/src/runtime/virtcontainers/qemu_amd64.go b/src/runtime/virtcontainers/qemu_amd64.go index 92c056de60..b8e49683c4 100644 --- a/src/runtime/virtcontainers/qemu_amd64.go +++ b/src/runtime/virtcontainers/qemu_amd64.go @@ -116,8 +116,8 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuAmd64{ qemuArchBase: qemuArchBase{ qemuMachine: *mp, + qemuExePath: qemuPaths[machineType], memoryOffset: config.MemOffset, - qemuPaths: qemuPaths, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, diff --git a/src/runtime/virtcontainers/qemu_arch_base.go b/src/runtime/virtcontainers/qemu_arch_base.go index 40fadc7c4c..ba2ab10385 100644 --- a/src/runtime/virtcontainers/qemu_arch_base.go +++ b/src/runtime/virtcontainers/qemu_arch_base.go @@ -41,7 +41,7 @@ type qemuArch interface { machine() govmmQemu.Machine // qemuPath returns the path to the QEMU binary - qemuPath() (string, error) + qemuPath() string // kernelParameters returns the kernel parameters // if debug is true then kernel debug parameters are included @@ -137,13 +137,13 @@ type qemuArch interface { type qemuArchBase struct { qemuMachine govmmQemu.Machine + qemuExePath string memoryOffset uint32 nestedRun bool vhost bool disableNvdimm bool dax bool networkIndex int - qemuPaths map[string]string kernelParamsNonDebug []Param kernelParamsDebug []Param kernelParams []Param @@ -242,13 +242,8 @@ func (q *qemuArchBase) machine() govmmQemu.Machine { return q.qemuMachine } -func (q *qemuArchBase) qemuPath() (string, error) { - p, ok := q.qemuPaths[q.qemuMachine.Type] - if !ok { - return "", fmt.Errorf("Unknown machine type: %s", q.qemuMachine.Type) - } - - return p, nil +func (q *qemuArchBase) qemuPath() string { + return q.qemuExePath } func (q *qemuArchBase) kernelParameters(debug bool) []Param { diff --git a/src/runtime/virtcontainers/qemu_arch_base_test.go b/src/runtime/virtcontainers/qemu_arch_base_test.go index 417a32b2a4..36da03bb7f 100644 --- a/src/runtime/virtcontainers/qemu_arch_base_test.go +++ b/src/runtime/virtcontainers/qemu_arch_base_test.go @@ -53,8 +53,8 @@ var qemuArchBaseKernelParams = []Param{ func newQemuArchBase() *qemuArchBase { return &qemuArchBase{ qemuMachine: qemuArchBaseMachine, + qemuExePath: qemuArchBaseQemuPaths[qemuArchBaseMachine.Type], nestedRun: false, - qemuPaths: qemuArchBaseQemuPaths, kernelParamsNonDebug: qemuArchBaseKernelParamsNonDebug, kernelParamsDebug: qemuArchBaseKernelParamsDebug, kernelParams: qemuArchBaseKernelParams, @@ -89,17 +89,8 @@ func TestQemuArchBaseQemuPath(t *testing.T) { assert := assert.New(t) qemuArchBase := newQemuArchBase() - p, err := qemuArchBase.qemuPath() - assert.NoError(err) + p := qemuArchBase.qemuPath() assert.Equal(p, qemuArchBaseQemuPath) - - paths := map[string]string{ - "bad": qemuArchBaseQemuPath, - } - qemuArchBase.qemuPaths = paths - p, err = qemuArchBase.qemuPath() - assert.Error(err) - assert.Equal("", p) } func TestQemuArchBaseKernelParameters(t *testing.T) { diff --git a/src/runtime/virtcontainers/qemu_arm64.go b/src/runtime/virtcontainers/qemu_arm64.go index eaec0087cb..dba48a3ecd 100644 --- a/src/runtime/virtcontainers/qemu_arm64.go +++ b/src/runtime/virtcontainers/qemu_arm64.go @@ -30,10 +30,6 @@ const qmpMigrationWaitTimeout = 10 * time.Second var defaultQemuMachineOptions = "usb=off,accel=kvm,gic-version=" + getGuestGICVersion() -var qemuPaths = map[string]string{ - QemuVirt: defaultQemuPath, -} - var kernelParams = []Param{ {"console", "hvc0"}, {"console", "hvc1"}, @@ -136,8 +132,8 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuArm64{ qemuArchBase{ qemuMachine: supportedQemuMachine, + qemuExePath: defaultQemuPath, memoryOffset: config.MemOffset, - qemuPaths: qemuPaths, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, diff --git a/src/runtime/virtcontainers/qemu_ppc64le.go b/src/runtime/virtcontainers/qemu_ppc64le.go index b6b22f0712..e19340da28 100644 --- a/src/runtime/virtcontainers/qemu_ppc64le.go +++ b/src/runtime/virtcontainers/qemu_ppc64le.go @@ -27,10 +27,6 @@ const defaultQemuMachineOptions = "accel=kvm,usb=off" const qmpMigrationWaitTimeout = 5 * time.Second -var qemuPaths = map[string]string{ - QemuPseries: defaultQemuPath, -} - var kernelParams = []Param{ {"rcupdate.rcu_expedited", "1"}, {"reboot", "k"}, @@ -68,8 +64,8 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuPPC64le{ qemuArchBase{ qemuMachine: supportedQemuMachine, + qemuExePath: defaultQemuPath, memoryOffset: config.MemOffset, - qemuPaths: qemuPaths, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, diff --git a/src/runtime/virtcontainers/qemu_s390x.go b/src/runtime/virtcontainers/qemu_s390x.go index 4ad12a5e69..beaad5eae4 100644 --- a/src/runtime/virtcontainers/qemu_s390x.go +++ b/src/runtime/virtcontainers/qemu_s390x.go @@ -29,10 +29,6 @@ const virtioSerialCCW = "virtio-serial-ccw" const qmpMigrationWaitTimeout = 5 * time.Second -var qemuPaths = map[string]string{ - QemuCCWVirtio: defaultQemuPath, -} - // Verify needed parameters var kernelParams = []Param{ {"console", "ttysclp0"}, @@ -66,8 +62,8 @@ func newQemuArch(config HypervisorConfig) (qemuArch, error) { q := &qemuS390x{ qemuArchBase{ qemuMachine: supportedQemuMachine, + qemuExePath: defaultQemuPath, memoryOffset: config.MemOffset, - qemuPaths: qemuPaths, kernelParamsNonDebug: kernelParamsNonDebug, kernelParamsDebug: kernelParamsDebug, kernelParams: kernelParams, diff --git a/src/runtime/virtcontainers/qemu_test.go b/src/runtime/virtcontainers/qemu_test.go index f1fe9924e6..e6c254031a 100644 --- a/src/runtime/virtcontainers/qemu_test.go +++ b/src/runtime/virtcontainers/qemu_test.go @@ -346,9 +346,7 @@ func TestQemuQemuPath(t *testing.T) { Type: "pc", Options: "", }, - qemuPaths: map[string]string{ - "pc": expectedPath, - }, + qemuExePath: expectedPath, } q := &qemu{ @@ -372,13 +370,6 @@ func TestQemuQemuPath(t *testing.T) { path, err = q.qemuPath() assert.NoError(err) assert.Equal(path, expectedPath) - - // bad machine type, arch should fail - qkvm.qemuMachine.Type = "rgb" - q.arch = qkvm - path, err = q.qemuPath() - assert.Error(err) - assert.Equal(path, "") } func TestHotplugUnsupportedDeviceType(t *testing.T) {