[mirror_qemu.git] / tests / acceptance / x86_cpu_model_versions.py

#!/usr/bin/env python
#
# Basic validation of x86 versioned CPU models and CPU model aliases
#
#  Copyright (c) 2019 Red Hat Inc
#
# Author:
#  Eduardo Habkost <ehabkost@redhat.com>
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, see <http://www.gnu.org/licenses/>.
#


import avocado_qemu
import re

class X86CPUModelAliases(avocado_qemu.Test):
    """
    Validation of PC CPU model versions and CPU model aliases

    :avocado: tags=arch:x86_64
    """
    def validate_aliases(self, cpus):
        for c in cpus.values():
            if 'alias-of' in c:
                # all aliases must point to a valid CPU model name:
                self.assertIn(c['alias-of'], cpus,
                              '%s.alias-of (%s) is not a valid CPU model name' % (c['name'], c['alias-of']))
                # aliases must not point to aliases
                self.assertNotIn('alias-of', cpus[c['alias-of']],
                                 '%s.alias-of (%s) points to another alias' % (c['name'], c['alias-of']))

                # aliases must not be static
                self.assertFalse(c['static'])

    def validate_variant_aliases(self, cpus):
        # -noTSX, -IBRS and -IBPB variants of CPU models are special:
        # they shouldn't have their own versions:
        self.assertNotIn("Haswell-noTSX-v1", cpus,
                         "Haswell-noTSX shouldn't be versioned")
        self.assertNotIn("Broadwell-noTSX-v1", cpus,
                         "Broadwell-noTSX shouldn't be versioned")
        self.assertNotIn("Nehalem-IBRS-v1", cpus,
                         "Nehalem-IBRS shouldn't be versioned")
        self.assertNotIn("Westmere-IBRS-v1", cpus,
                         "Westmere-IBRS shouldn't be versioned")
        self.assertNotIn("SandyBridge-IBRS-v1", cpus,
                         "SandyBridge-IBRS shouldn't be versioned")
        self.assertNotIn("IvyBridge-IBRS-v1", cpus,
                         "IvyBridge-IBRS shouldn't be versioned")
        self.assertNotIn("Haswell-noTSX-IBRS-v1", cpus,
                         "Haswell-noTSX-IBRS shouldn't be versioned")
        self.assertNotIn("Haswell-IBRS-v1", cpus,
                         "Haswell-IBRS shouldn't be versioned")
        self.assertNotIn("Broadwell-noTSX-IBRS-v1", cpus,
                         "Broadwell-noTSX-IBRS shouldn't be versioned")
        self.assertNotIn("Broadwell-IBRS-v1", cpus,
                         "Broadwell-IBRS shouldn't be versioned")
        self.assertNotIn("Skylake-Client-IBRS-v1", cpus,
                         "Skylake-Client-IBRS shouldn't be versioned")
        self.assertNotIn("Skylake-Server-IBRS-v1", cpus,
                         "Skylake-Server-IBRS shouldn't be versioned")
        self.assertNotIn("EPYC-IBPB-v1", cpus,
                         "EPYC-IBPB shouldn't be versioned")

    def test_4_0_alias_compatibility(self):
        """Check if pc-*-4.0 unversioned CPU model won't be reported as aliases"""
        # pc-*-4.0 won't expose non-versioned CPU models as aliases
        # We do this to help management software to keep compatibility
        # with older QEMU versions that didn't have the versioned CPU model
        self.vm.add_args('-S')
        self.vm.set_machine('pc-i440fx-4.0')
        self.vm.launch()
        cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))

        self.assertFalse(cpus['Cascadelake-Server']['static'],
                         'unversioned Cascadelake-Server CPU model must not be static')
        self.assertNotIn('alias-of', cpus['Cascadelake-Server'],
                         'Cascadelake-Server must not be an alias')
        self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
                         'Cascadelake-Server-v1 must not be an alias')

        self.assertFalse(cpus['qemu64']['static'],
                         'unversioned qemu64 CPU model must not be static')
        self.assertNotIn('alias-of', cpus['qemu64'],
                         'qemu64 must not be an alias')
        self.assertNotIn('alias-of', cpus['qemu64-v1'],
                         'qemu64-v1 must not be an alias')

        self.validate_variant_aliases(cpus)

        # On pc-*-4.0, no CPU model should be reported as an alias:
        for name,c in cpus.items():
            self.assertNotIn('alias-of', c, "%s shouldn't be an alias" % (name))

    def test_4_1_alias(self):
        """Check if unversioned CPU model is an alias pointing to right version"""
        self.vm.add_args('-S')
        self.vm.set_machine('pc-i440fx-4.1')
        self.vm.launch()

        cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))

        self.assertFalse(cpus['Cascadelake-Server']['static'],
                         'unversioned Cascadelake-Server CPU model must not be static')
        self.assertEquals(cpus['Cascadelake-Server'].get('alias-of'), 'Cascadelake-Server-v1',
                          'Cascadelake-Server must be an alias of Cascadelake-Server-v1')
        self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
                         'Cascadelake-Server-v1 must not be an alias')

        self.assertFalse(cpus['qemu64']['static'],
                         'unversioned qemu64 CPU model must not be static')
        self.assertEquals(cpus['qemu64'].get('alias-of'), 'qemu64-v1',
                          'qemu64 must be an alias of qemu64-v1')
        self.assertNotIn('alias-of', cpus['qemu64-v1'],
                         'qemu64-v1 must not be an alias')

        self.validate_variant_aliases(cpus)

        # On pc-*-4.1, -noTSX and -IBRS models should be aliases:
        self.assertEquals(cpus["Haswell"].get('alias-of'),
                          "Haswell-v1",
                         "Haswell must be an alias")
        self.assertEquals(cpus["Haswell-noTSX"].get('alias-of'),
                          "Haswell-v2",
                         "Haswell-noTSX must be an alias")
        self.assertEquals(cpus["Haswell-IBRS"].get('alias-of'),
                          "Haswell-v3",
                         "Haswell-IBRS must be an alias")
        self.assertEquals(cpus["Haswell-noTSX-IBRS"].get('alias-of'),
                          "Haswell-v4",
                         "Haswell-noTSX-IBRS must be an alias")

        self.assertEquals(cpus["Broadwell"].get('alias-of'),
                          "Broadwell-v1",
                         "Broadwell must be an alias")
        self.assertEquals(cpus["Broadwell-noTSX"].get('alias-of'),
                          "Broadwell-v2",
                         "Broadwell-noTSX must be an alias")
        self.assertEquals(cpus["Broadwell-IBRS"].get('alias-of'),
                          "Broadwell-v3",
                         "Broadwell-IBRS must be an alias")
        self.assertEquals(cpus["Broadwell-noTSX-IBRS"].get('alias-of'),
                          "Broadwell-v4",
                         "Broadwell-noTSX-IBRS must be an alias")

        self.assertEquals(cpus["Nehalem"].get('alias-of'),
                          "Nehalem-v1",
                         "Nehalem must be an alias")
        self.assertEquals(cpus["Nehalem-IBRS"].get('alias-of'),
                          "Nehalem-v2",
                         "Nehalem-IBRS must be an alias")

        self.assertEquals(cpus["Westmere"].get('alias-of'),
                          "Westmere-v1",
                         "Westmere must be an alias")
        self.assertEquals(cpus["Westmere-IBRS"].get('alias-of'),
                          "Westmere-v2",
                         "Westmere-IBRS must be an alias")

        self.assertEquals(cpus["SandyBridge"].get('alias-of'),
                          "SandyBridge-v1",
                         "SandyBridge must be an alias")
        self.assertEquals(cpus["SandyBridge-IBRS"].get('alias-of'),
                          "SandyBridge-v2",
                         "SandyBridge-IBRS must be an alias")

        self.assertEquals(cpus["IvyBridge"].get('alias-of'),
                          "IvyBridge-v1",
                         "IvyBridge must be an alias")
        self.assertEquals(cpus["IvyBridge-IBRS"].get('alias-of'),
                          "IvyBridge-v2",
                         "IvyBridge-IBRS must be an alias")

        self.assertEquals(cpus["Skylake-Client"].get('alias-of'),
                          "Skylake-Client-v1",
                         "Skylake-Client must be an alias")
        self.assertEquals(cpus["Skylake-Client-IBRS"].get('alias-of'),
                          "Skylake-Client-v2",
                         "Skylake-Client-IBRS must be an alias")

        self.assertEquals(cpus["Skylake-Server"].get('alias-of'),
                          "Skylake-Server-v1",
                         "Skylake-Server must be an alias")
        self.assertEquals(cpus["Skylake-Server-IBRS"].get('alias-of'),
                          "Skylake-Server-v2",
                         "Skylake-Server-IBRS must be an alias")

        self.assertEquals(cpus["EPYC"].get('alias-of'),
                          "EPYC-v1",
                         "EPYC must be an alias")
        self.assertEquals(cpus["EPYC-IBPB"].get('alias-of'),
                          "EPYC-v2",
                         "EPYC-IBPB must be an alias")

        self.validate_aliases(cpus)

    def test_none_alias(self):
        """Check if unversioned CPU model is an alias pointing to some version"""
        self.vm.add_args('-S')
        self.vm.set_machine('none')
        self.vm.launch()

        cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))

        self.assertFalse(cpus['Cascadelake-Server']['static'],
                         'unversioned Cascadelake-Server CPU model must not be static')
        self.assertTrue(re.match('Cascadelake-Server-v[0-9]+', cpus['Cascadelake-Server']['alias-of']),
                        'Cascadelake-Server must be an alias of versioned CPU model')
        self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
                         'Cascadelake-Server-v1 must not be an alias')

        self.assertFalse(cpus['qemu64']['static'],
                         'unversioned qemu64 CPU model must not be static')
        self.assertTrue(re.match('qemu64-v[0-9]+', cpus['qemu64']['alias-of']),
                        'qemu64 must be an alias of versioned CPU model')
        self.assertNotIn('alias-of', cpus['qemu64-v1'],
                         'qemu64-v1 must not be an alias')

        self.validate_aliases(cpus)
Commit	Line	Data
dcafd1ef EH	1	#!/usr/bin/env python
	2	#
	3	# Basic validation of x86 versioned CPU models and CPU model aliases
	4	#
	5	# Copyright (c) 2019 Red Hat Inc
	6	#
	7	# Author:
	8	# Eduardo Habkost <ehabkost@redhat.com>
	9	#
	10	# This library is free software; you can redistribute it and/or
	11	# modify it under the terms of the GNU Lesser General Public
	12	# License as published by the Free Software Foundation; either
	13	# version 2 of the License, or (at your option) any later version.
	14	#
	15	# This library is distributed in the hope that it will be useful,
	16	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	# Lesser General Public License for more details.
	19	#
	20	# You should have received a copy of the GNU Lesser General Public
	21	# License along with this library; if not, see <http://www.gnu.org/licenses/>.
	22	#
	23
	24
	25	import avocado_qemu
	26	import re
	27
	28	class X86CPUModelAliases(avocado_qemu.Test):
	29	"""
	30	Validation of PC CPU model versions and CPU model aliases
	31
	32	:avocado: tags=arch:x86_64
	33	"""
	34	def validate_aliases(self, cpus):
	35	for c in cpus.values():
	36	if 'alias-of' in c:
	37	# all aliases must point to a valid CPU model name:
	38	self.assertIn(c['alias-of'], cpus,
	39	'%s.alias-of (%s) is not a valid CPU model name' % (c['name'], c['alias-of']))
	40	# aliases must not point to aliases
	41	self.assertNotIn('alias-of', cpus[c['alias-of']],
	42	'%s.alias-of (%s) points to another alias' % (c['name'], c['alias-of']))
	43
	44	# aliases must not be static
	45	self.assertFalse(c['static'])
	46
	47	def validate_variant_aliases(self, cpus):
	48	# -noTSX, -IBRS and -IBPB variants of CPU models are special:
	49	# they shouldn't have their own versions:
	50	self.assertNotIn("Haswell-noTSX-v1", cpus,
	51	"Haswell-noTSX shouldn't be versioned")
	52	self.assertNotIn("Broadwell-noTSX-v1", cpus,
	53	"Broadwell-noTSX shouldn't be versioned")
	54	self.assertNotIn("Nehalem-IBRS-v1", cpus,
	55	"Nehalem-IBRS shouldn't be versioned")
	56	self.assertNotIn("Westmere-IBRS-v1", cpus,
	57	"Westmere-IBRS shouldn't be versioned")
	58	self.assertNotIn("SandyBridge-IBRS-v1", cpus,
	59	"SandyBridge-IBRS shouldn't be versioned")
	60	self.assertNotIn("IvyBridge-IBRS-v1", cpus,
	61	"IvyBridge-IBRS shouldn't be versioned")
	62	self.assertNotIn("Haswell-noTSX-IBRS-v1", cpus,
	63	"Haswell-noTSX-IBRS shouldn't be versioned")
	64	self.assertNotIn("Haswell-IBRS-v1", cpus,
65	"Haswell-IBRS shouldn't be versioned")
66	self.assertNotIn("Broadwell-noTSX-IBRS-v1", cpus,
67	"Broadwell-noTSX-IBRS shouldn't be versioned")
68	self.assertNotIn("Broadwell-IBRS-v1", cpus,
69	"Broadwell-IBRS shouldn't be versioned")
70	self.assertNotIn("Skylake-Client-IBRS-v1", cpus,
71	"Skylake-Client-IBRS shouldn't be versioned")
72	self.assertNotIn("Skylake-Server-IBRS-v1", cpus,
73	"Skylake-Server-IBRS shouldn't be versioned")
74	self.assertNotIn("EPYC-IBPB-v1", cpus,
75	"EPYC-IBPB shouldn't be versioned")
76
77	def test_4_0_alias_compatibility(self):
78	"""Check if pc-*-4.0 unversioned CPU model won't be reported as aliases"""
79	# pc-*-4.0 won't expose non-versioned CPU models as aliases
80	# We do this to help management software to keep compatibility
81	# with older QEMU versions that didn't have the versioned CPU model
82	self.vm.add_args('-S')
83	self.vm.set_machine('pc-i440fx-4.0')
84	self.vm.launch()
85	cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))
86
87	self.assertFalse(cpus['Cascadelake-Server']['static'],
88	'unversioned Cascadelake-Server CPU model must not be static')
89	self.assertNotIn('alias-of', cpus['Cascadelake-Server'],
90	'Cascadelake-Server must not be an alias')
91	self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
92	'Cascadelake-Server-v1 must not be an alias')
93
94	self.assertFalse(cpus['qemu64']['static'],
95	'unversioned qemu64 CPU model must not be static')
96	self.assertNotIn('alias-of', cpus['qemu64'],
97	'qemu64 must not be an alias')
98	self.assertNotIn('alias-of', cpus['qemu64-v1'],
99	'qemu64-v1 must not be an alias')
100
101	self.validate_variant_aliases(cpus)
102
103	# On pc-*-4.0, no CPU model should be reported as an alias:
104	for name,c in cpus.items():
105	self.assertNotIn('alias-of', c, "%s shouldn't be an alias" % (name))
0788a56b EH	106
	107	def test_4_1_alias(self):
	108	"""Check if unversioned CPU model is an alias pointing to right version"""
	109	self.vm.add_args('-S')
	110	self.vm.set_machine('pc-i440fx-4.1')
	111	self.vm.launch()
	112
	113	cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))
	114
	115	self.assertFalse(cpus['Cascadelake-Server']['static'],
	116	'unversioned Cascadelake-Server CPU model must not be static')
	117	self.assertEquals(cpus['Cascadelake-Server'].get('alias-of'), 'Cascadelake-Server-v1',
	118	'Cascadelake-Server must be an alias of Cascadelake-Server-v1')
	119	self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
	120	'Cascadelake-Server-v1 must not be an alias')
	121
	122	self.assertFalse(cpus['qemu64']['static'],
	123	'unversioned qemu64 CPU model must not be static')
	124	self.assertEquals(cpus['qemu64'].get('alias-of'), 'qemu64-v1',
	125	'qemu64 must be an alias of qemu64-v1')
	126	self.assertNotIn('alias-of', cpus['qemu64-v1'],
	127	'qemu64-v1 must not be an alias')
	128
	129	self.validate_variant_aliases(cpus)
	130
	131	# On pc-*-4.1, -noTSX and -IBRS models should be aliases:
	132	self.assertEquals(cpus["Haswell"].get('alias-of'),
	133	"Haswell-v1",
	134	"Haswell must be an alias")
	135	self.assertEquals(cpus["Haswell-noTSX"].get('alias-of'),
	136	"Haswell-v2",
	137	"Haswell-noTSX must be an alias")
	138	self.assertEquals(cpus["Haswell-IBRS"].get('alias-of'),
	139	"Haswell-v3",
	140	"Haswell-IBRS must be an alias")
	141	self.assertEquals(cpus["Haswell-noTSX-IBRS"].get('alias-of'),
	142	"Haswell-v4",
	143	"Haswell-noTSX-IBRS must be an alias")
	144
	145	self.assertEquals(cpus["Broadwell"].get('alias-of'),
	146	"Broadwell-v1",
	147	"Broadwell must be an alias")
	148	self.assertEquals(cpus["Broadwell-noTSX"].get('alias-of'),
	149	"Broadwell-v2",
	150	"Broadwell-noTSX must be an alias")
	151	self.assertEquals(cpus["Broadwell-IBRS"].get('alias-of'),
	152	"Broadwell-v3",
	153	"Broadwell-IBRS must be an alias")
	154	self.assertEquals(cpus["Broadwell-noTSX-IBRS"].get('alias-of'),
	155	"Broadwell-v4",
	156	"Broadwell-noTSX-IBRS must be an alias")
	157
	158	self.assertEquals(cpus["Nehalem"].get('alias-of'),
	159	"Nehalem-v1",
	160	"Nehalem must be an alias")
	161	self.assertEquals(cpus["Nehalem-IBRS"].get('alias-of'),
	162	"Nehalem-v2",
	163	"Nehalem-IBRS must be an alias")
	164
	165	self.assertEquals(cpus["Westmere"].get('alias-of'),
	166	"Westmere-v1",
	167	"Westmere must be an alias")
	168	self.assertEquals(cpus["Westmere-IBRS"].get('alias-of'),
	169	"Westmere-v2",
170	"Westmere-IBRS must be an alias")
171
172	self.assertEquals(cpus["SandyBridge"].get('alias-of'),
173	"SandyBridge-v1",
174	"SandyBridge must be an alias")
175	self.assertEquals(cpus["SandyBridge-IBRS"].get('alias-of'),
176	"SandyBridge-v2",
177	"SandyBridge-IBRS must be an alias")
178
179	self.assertEquals(cpus["IvyBridge"].get('alias-of'),
180	"IvyBridge-v1",
181	"IvyBridge must be an alias")
182	self.assertEquals(cpus["IvyBridge-IBRS"].get('alias-of'),
183	"IvyBridge-v2",
184	"IvyBridge-IBRS must be an alias")
185
186	self.assertEquals(cpus["Skylake-Client"].get('alias-of'),
187	"Skylake-Client-v1",
188	"Skylake-Client must be an alias")
189	self.assertEquals(cpus["Skylake-Client-IBRS"].get('alias-of'),
190	"Skylake-Client-v2",
191	"Skylake-Client-IBRS must be an alias")
192
193	self.assertEquals(cpus["Skylake-Server"].get('alias-of'),
194	"Skylake-Server-v1",
195	"Skylake-Server must be an alias")
196	self.assertEquals(cpus["Skylake-Server-IBRS"].get('alias-of'),
197	"Skylake-Server-v2",
198	"Skylake-Server-IBRS must be an alias")
199
200	self.assertEquals(cpus["EPYC"].get('alias-of'),
201	"EPYC-v1",
202	"EPYC must be an alias")
203	self.assertEquals(cpus["EPYC-IBPB"].get('alias-of'),
204	"EPYC-v2",
205	"EPYC-IBPB must be an alias")
206
207	self.validate_aliases(cpus)
208
209	def test_none_alias(self):
210	"""Check if unversioned CPU model is an alias pointing to some version"""
211	self.vm.add_args('-S')
212	self.vm.set_machine('none')
213	self.vm.launch()
214
215	cpus = dict((m['name'], m) for m in self.vm.command('query-cpu-definitions'))
216
217	self.assertFalse(cpus['Cascadelake-Server']['static'],
218	'unversioned Cascadelake-Server CPU model must not be static')
219	self.assertTrue(re.match('Cascadelake-Server-v[0-9]+', cpus['Cascadelake-Server']['alias-of']),
220	'Cascadelake-Server must be an alias of versioned CPU model')
221	self.assertNotIn('alias-of', cpus['Cascadelake-Server-v1'],
222	'Cascadelake-Server-v1 must not be an alias')
223
224	self.assertFalse(cpus['qemu64']['static'],
225	'unversioned qemu64 CPU model must not be static')
226	self.assertTrue(re.match('qemu64-v[0-9]+', cpus['qemu64']['alias-of']),
227	'qemu64 must be an alias of versioned CPU model')
228	self.assertNotIn('alias-of', cpus['qemu64-v1'],
229	'qemu64-v1 must not be an alias')
230
231	self.validate_aliases(cpus)