tests/avocado/s390_topology.py

   1 # Functional test that boots a Linux kernel and checks the console
   2 #
   3 # Copyright IBM Corp. 2023
   4 #
   5 # Author:
   6 #  Pierre Morel <pmorel@linux.ibm.com>
   7 #
   8 # This work is licensed under the terms of the GNU GPL, version 2 or
   9 # later.  See the COPYING file in the top-level directory.
  10
  11 import os
  12 import shutil
  13 import time
  14
  15 from avocado_qemu import QemuSystemTest
  16 from avocado_qemu import exec_command
  17 from avocado_qemu import exec_command_and_wait_for_pattern
  18 from avocado_qemu import interrupt_interactive_console_until_pattern
  19 from avocado_qemu import wait_for_console_pattern
  20 from avocado.utils import process
  21 from avocado.utils import archive
  22
  23
  24 class S390CPUTopology(QemuSystemTest):
  25     """
  26     S390x CPU topology consists of 4 topology layers, from bottom to top,
  27     the cores, sockets, books and drawers and 2 modifiers attributes,
  28     the entitlement and the dedication.
  29     See: docs/system/s390x/cpu-topology.rst.
  30
  31     S390x CPU topology is setup in different ways:
  32     - implicitly from the '-smp' argument by completing each topology
  33       level one after the other beginning with drawer 0, book 0 and
  34       socket 0.
  35     - explicitly from the '-device' argument on the QEMU command line
  36     - explicitly by hotplug of a new CPU using QMP or HMP
  37     - it is modified by using QMP 'set-cpu-topology'
  38
  39     The S390x modifier attribute entitlement depends on the machine
  40     polarization, which can be horizontal or vertical.
  41     The polarization is changed on a request from the guest.
  42     """
  43     timeout = 90
  44     event_timeout = 10
  45
  46     KERNEL_COMMON_COMMAND_LINE = ('printk.time=0 '
  47                                   'root=/dev/ram '
  48                                   'selinux=0 '
  49                                   'rdinit=/bin/sh')
  50
  51     def wait_until_booted(self):
  52         wait_for_console_pattern(self, 'no job control',
  53                                  failure_message='Kernel panic - not syncing',
  54                                  vm=None)
  55
  56     def check_topology(self, c, s, b, d, e, t):
  57         res = self.vm.qmp('query-cpus-fast')
  58         cpus =  res['return']
  59         for cpu in cpus:
  60             core = cpu['props']['core-id']
  61             socket = cpu['props']['socket-id']
  62             book = cpu['props']['book-id']
  63             drawer = cpu['props']['drawer-id']
  64             entitlement = cpu.get('entitlement')
  65             dedicated = cpu.get('dedicated')
  66             if core == c:
  67                 self.assertEqual(drawer, d)
  68                 self.assertEqual(book, b)
  69                 self.assertEqual(socket, s)
  70                 self.assertEqual(entitlement, e)
  71                 self.assertEqual(dedicated, t)
  72
  73     def kernel_init(self):
  74         """
  75         We need a VM that supports CPU topology,
  76         currently this only the case when using KVM, not TCG.
  77         We need a kernel supporting the CPU topology.
  78         We need a minimal root filesystem with a shell.
  79         """
  80         self.require_accelerator("kvm")
  81         kernel_url = ('https://archives.fedoraproject.org/pub/archive'
  82                       '/fedora-secondary/releases/35/Server/s390x/os'
  83                       '/images/kernel.img')
  84         kernel_hash = '0d1aaaf303f07cf0160c8c48e56fe638'
  85         kernel_path = self.fetch_asset(kernel_url, algorithm='md5',
  86                                        asset_hash=kernel_hash)
  87
  88         initrd_url = ('https://archives.fedoraproject.org/pub/archive'
  89                       '/fedora-secondary/releases/35/Server/s390x/os'
  90                       '/images/initrd.img')
  91         initrd_hash = 'a122057d95725ac030e2ec51df46e172'
  92         initrd_path_xz = self.fetch_asset(initrd_url, algorithm='md5',
  93                                           asset_hash=initrd_hash)
  94         initrd_path = os.path.join(self.workdir, 'initrd-raw.img')
  95         archive.lzma_uncompress(initrd_path_xz, initrd_path)
  96
  97         self.vm.set_console()
  98         kernel_command_line = self.KERNEL_COMMON_COMMAND_LINE
  99         self.vm.add_args('-nographic',
 100                          '-enable-kvm',
 101                          '-cpu', 'max,ctop=on',
 102                          '-m', '512',
 103                          '-kernel', kernel_path,
 104                          '-initrd', initrd_path,
 105                          '-append', kernel_command_line)
 106
 107     def system_init(self):
 108         self.log.info("System init")
 109         exec_command_and_wait_for_pattern(self,
 110                 """ mount proc -t proc /proc;
 111                     mount sys -t sysfs /sys;
 112                     cat /sys/devices/system/cpu/dispatching """,
 113                     '0')
 114
 115     def test_single(self):
 116         """
 117         This test checks the simplest topology with a single CPU.
 118
 119         :avocado: tags=arch:s390x
 120         :avocado: tags=machine:s390-ccw-virtio
 121         """
 122         self.kernel_init()
 123         self.vm.launch()
 124         self.wait_until_booted()
 125         self.check_topology(0, 0, 0, 0, 'medium', False)
 126
 127     def test_default(self):
 128         """
 129         This test checks the implicit topology.
 130
 131         :avocado: tags=arch:s390x
 132         :avocado: tags=machine:s390-ccw-virtio
 133         """
 134         self.kernel_init()
 135         self.vm.add_args('-smp',
 136                          '13,drawers=2,books=2,sockets=3,cores=2,maxcpus=24')
 137         self.vm.launch()
 138         self.wait_until_booted()
 139         self.check_topology(0, 0, 0, 0, 'medium', False)
 140         self.check_topology(1, 0, 0, 0, 'medium', False)
 141         self.check_topology(2, 1, 0, 0, 'medium', False)
 142         self.check_topology(3, 1, 0, 0, 'medium', False)
 143         self.check_topology(4, 2, 0, 0, 'medium', False)
 144         self.check_topology(5, 2, 0, 0, 'medium', False)
 145         self.check_topology(6, 0, 1, 0, 'medium', False)
 146         self.check_topology(7, 0, 1, 0, 'medium', False)
 147         self.check_topology(8, 1, 1, 0, 'medium', False)
 148         self.check_topology(9, 1, 1, 0, 'medium', False)
 149         self.check_topology(10, 2, 1, 0, 'medium', False)
 150         self.check_topology(11, 2, 1, 0, 'medium', False)
 151         self.check_topology(12, 0, 0, 1, 'medium', False)
 152
 153     def test_move(self):
 154         """
 155         This test checks the topology modification by moving a CPU
 156         to another socket: CPU 0 is moved from socket 0 to socket 2.
 157
 158         :avocado: tags=arch:s390x
 159         :avocado: tags=machine:s390-ccw-virtio
 160         """
 161         self.kernel_init()
 162         self.vm.add_args('-smp',
 163                          '1,drawers=2,books=2,sockets=3,cores=2,maxcpus=24')
 164         self.vm.launch()
 165         self.wait_until_booted()
 166
 167         self.check_topology(0, 0, 0, 0, 'medium', False)
 168         res = self.vm.qmp('set-cpu-topology',
 169                           {'core-id': 0, 'socket-id': 2, 'entitlement': 'low'})
 170         self.assertEqual(res['return'], {})
 171         self.check_topology(0, 2, 0, 0, 'low', False)
 172
 173     def test_dash_device(self):
 174         """
 175         This test verifies that a CPU defined with the '-device'
 176         command line option finds its right place inside the topology.
 177
 178         :avocado: tags=arch:s390x
 179         :avocado: tags=machine:s390-ccw-virtio
 180         """
 181         self.kernel_init()
 182         self.vm.add_args('-smp',
 183                          '1,drawers=2,books=2,sockets=3,cores=2,maxcpus=24')
 184         self.vm.add_args('-device', 'max-s390x-cpu,core-id=10')
 185         self.vm.add_args('-device',
 186                          'max-s390x-cpu,'
 187                          'core-id=1,socket-id=0,book-id=1,drawer-id=1,entitlement=low')
 188         self.vm.add_args('-device',
 189                          'max-s390x-cpu,'
 190                          'core-id=2,socket-id=0,book-id=1,drawer-id=1,entitlement=medium')
 191         self.vm.add_args('-device',
 192                          'max-s390x-cpu,'
 193                          'core-id=3,socket-id=1,book-id=1,drawer-id=1,entitlement=high')
 194         self.vm.add_args('-device',
 195                          'max-s390x-cpu,'
 196                          'core-id=4,socket-id=1,book-id=1,drawer-id=1')
 197         self.vm.add_args('-device',
 198                          'max-s390x-cpu,'
 199                          'core-id=5,socket-id=2,book-id=1,drawer-id=1,dedicated=true')
 200
 201         self.vm.launch()
 202         self.wait_until_booted()
 203
 204         self.check_topology(10, 2, 1, 0, 'medium', False)
 205         self.check_topology(1, 0, 1, 1, 'low', False)
 206         self.check_topology(2, 0, 1, 1, 'medium', False)
 207         self.check_topology(3, 1, 1, 1, 'high', False)
 208         self.check_topology(4, 1, 1, 1, 'medium', False)
 209         self.check_topology(5, 2, 1, 1, 'high', True)
 210
 211
 212     def guest_set_dispatching(self, dispatching):
 213         exec_command(self,
 214                 f'echo {dispatching} > /sys/devices/system/cpu/dispatching')
 215         self.vm.event_wait('CPU_POLARIZATION_CHANGE', self.event_timeout)
 216         exec_command_and_wait_for_pattern(self,
 217                 'cat /sys/devices/system/cpu/dispatching', dispatching)
 218
 219
 220     def test_polarization(self):
 221         """
 222         This test verifies that QEMU modifies the entitlement change after
 223         several guest polarization change requests.
 224
 225         :avocado: tags=arch:s390x
 226         :avocado: tags=machine:s390-ccw-virtio
 227         """
 228         self.kernel_init()
 229         self.vm.launch()
 230         self.wait_until_booted()
 231
 232         self.system_init()
 233         res = self.vm.qmp('query-s390x-cpu-polarization')
 234         self.assertEqual(res['return']['polarization'], 'horizontal')
 235         self.check_topology(0, 0, 0, 0, 'medium', False)
 236
 237         self.guest_set_dispatching('1');
 238         res = self.vm.qmp('query-s390x-cpu-polarization')
 239         self.assertEqual(res['return']['polarization'], 'vertical')
 240         self.check_topology(0, 0, 0, 0, 'medium', False)
 241
 242         self.guest_set_dispatching('0');
 243         res = self.vm.qmp('query-s390x-cpu-polarization')
 244         self.assertEqual(res['return']['polarization'], 'horizontal')
 245         self.check_topology(0, 0, 0, 0, 'medium', False)
 246
 247
 248     def check_polarization(self, polarization):
 249         #We need to wait for the change to have been propagated to the kernel
 250         exec_command_and_wait_for_pattern(self,
 251             "\n".join([
 252                 "timeout 1 sh -c 'while true",
 253                 'do',
 254                 '    syspath="/sys/devices/system/cpu/cpu0/polarization"',
 255                 '    polarization="$(cat "$syspath")" || exit',
 256                f'    if [ "$polarization" = "{polarization}" ]; then',
 257                 '        exit 0',
 258                 '    fi',
 259                 '    sleep 0.01',
 260                 #searched for strings mustn't show up in command, '' to obfuscate
 261                 "done' && echo succ''ess || echo fail''ure",
 262             ]),
 263             "success", "failure")
 264
 265
 266     def test_entitlement(self):
 267         """
 268         This test verifies that QEMU modifies the entitlement
 269         after a guest request and that the guest sees the change.
 270
 271         :avocado: tags=arch:s390x
 272         :avocado: tags=machine:s390-ccw-virtio
 273         """
 274         self.kernel_init()
 275         self.vm.launch()
 276         self.wait_until_booted()
 277
 278         self.system_init()
 279
 280         self.check_polarization('horizontal')
 281         self.check_topology(0, 0, 0, 0, 'medium', False)
 282
 283         self.guest_set_dispatching('1')
 284         self.check_polarization('vertical:medium')
 285         self.check_topology(0, 0, 0, 0, 'medium', False)
 286
 287         res = self.vm.qmp('set-cpu-topology',
 288                           {'core-id': 0, 'entitlement': 'low'})
 289         self.assertEqual(res['return'], {})
 290         self.check_polarization('vertical:low')
 291         self.check_topology(0, 0, 0, 0, 'low', False)
 292
 293         res = self.vm.qmp('set-cpu-topology',
 294                           {'core-id': 0, 'entitlement': 'medium'})
 295         self.assertEqual(res['return'], {})
 296         self.check_polarization('vertical:medium')
 297         self.check_topology(0, 0, 0, 0, 'medium', False)
 298
 299         res = self.vm.qmp('set-cpu-topology',
 300                           {'core-id': 0, 'entitlement': 'high'})
 301         self.assertEqual(res['return'], {})
 302         self.check_polarization('vertical:high')
 303         self.check_topology(0, 0, 0, 0, 'high', False)
 304
 305         self.guest_set_dispatching('0');
 306         self.check_polarization("horizontal")
 307         self.check_topology(0, 0, 0, 0, 'high', False)
 308
 309
 310     def test_dedicated(self):
 311         """
 312         This test verifies that QEMU adjusts the entitlement correctly when a
 313         CPU is made dedicated.
 314         QEMU retains the entitlement value when horizontal polarization is in effect.
 315         For the guest, the field shows the effective value of the entitlement.
 316
 317         :avocado: tags=arch:s390x
 318         :avocado: tags=machine:s390-ccw-virtio
 319         """
 320         self.kernel_init()
 321         self.vm.launch()
 322         self.wait_until_booted()
 323
 324         self.system_init()
 325
 326         self.check_polarization("horizontal")
 327
 328         res = self.vm.qmp('set-cpu-topology',
 329                           {'core-id': 0, 'dedicated': True})
 330         self.assertEqual(res['return'], {})
 331         self.check_topology(0, 0, 0, 0, 'high', True)
 332         self.check_polarization("horizontal")
 333
 334         self.guest_set_dispatching('1');
 335         self.check_topology(0, 0, 0, 0, 'high', True)
 336         self.check_polarization("vertical:high")
 337
 338         self.guest_set_dispatching('0');
 339         self.check_topology(0, 0, 0, 0, 'high', True)
 340         self.check_polarization("horizontal")
 341
 342
 343     def test_socket_full(self):
 344         """
 345         This test verifies that QEMU does not accept to overload a socket.
 346         The socket-id 0 on book-id 0 already contains CPUs 0 and 1 and can
 347         not accept any new CPU while socket-id 0 on book-id 1 is free.
 348
 349         :avocado: tags=arch:s390x
 350         :avocado: tags=machine:s390-ccw-virtio
 351         """
 352         self.kernel_init()
 353         self.vm.add_args('-smp',
 354                          '3,drawers=2,books=2,sockets=3,cores=2,maxcpus=24')
 355         self.vm.launch()
 356         self.wait_until_booted()
 357
 358         self.system_init()
 359
 360         res = self.vm.qmp('set-cpu-topology',
 361                           {'core-id': 2, 'socket-id': 0, 'book-id': 0})
 362         self.assertEqual(res['error']['class'], 'GenericError')
 363
 364         res = self.vm.qmp('set-cpu-topology',
 365                           {'core-id': 2, 'socket-id': 0, 'book-id': 1})
 366         self.assertEqual(res['return'], {})
 367
 368     def test_dedicated_error(self):
 369         """
 370         This test verifies that QEMU refuses to lower the entitlement
 371         of a dedicated CPU
 372
 373         :avocado: tags=arch:s390x
 374         :avocado: tags=machine:s390-ccw-virtio
 375         """
 376         self.kernel_init()
 377         self.vm.launch()
 378         self.wait_until_booted()
 379
 380         self.system_init()
 381
 382         res = self.vm.qmp('set-cpu-topology',
 383                           {'core-id': 0, 'dedicated': True})
 384         self.assertEqual(res['return'], {})
 385
 386         self.check_topology(0, 0, 0, 0, 'high', True)
 387
 388         self.guest_set_dispatching('1');
 389
 390         self.check_topology(0, 0, 0, 0, 'high', True)
 391
 392         res = self.vm.qmp('set-cpu-topology',
 393                           {'core-id': 0, 'entitlement': 'low', 'dedicated': True})
 394         self.assertEqual(res['error']['class'], 'GenericError')
 395
 396         res = self.vm.qmp('set-cpu-topology',
 397                           {'core-id': 0, 'entitlement': 'low'})
 398         self.assertEqual(res['error']['class'], 'GenericError')
 399
 400         res = self.vm.qmp('set-cpu-topology',
 401                           {'core-id': 0, 'entitlement': 'medium', 'dedicated': True})
 402         self.assertEqual(res['error']['class'], 'GenericError')
 403
 404         res = self.vm.qmp('set-cpu-topology',
 405                           {'core-id': 0, 'entitlement': 'medium'})
 406         self.assertEqual(res['error']['class'], 'GenericError')
 407
 408         res = self.vm.qmp('set-cpu-topology',
 409                           {'core-id': 0, 'entitlement': 'low', 'dedicated': False})
 410         self.assertEqual(res['return'], {})
 411
 412         res = self.vm.qmp('set-cpu-topology',
 413                           {'core-id': 0, 'entitlement': 'medium', 'dedicated': False})
 414         self.assertEqual(res['return'], {})
 415
 416     def test_move_error(self):
 417         """
 418         This test verifies that QEMU refuses to move a CPU to an
 419         nonexistent location
 420
 421         :avocado: tags=arch:s390x
 422         :avocado: tags=machine:s390-ccw-virtio
 423         """
 424         self.kernel_init()
 425         self.vm.launch()
 426         self.wait_until_booted()
 427
 428         self.system_init()
 429
 430         res = self.vm.qmp('set-cpu-topology', {'core-id': 0, 'drawer-id': 1})
 431         self.assertEqual(res['error']['class'], 'GenericError')
 432
 433         res = self.vm.qmp('set-cpu-topology', {'core-id': 0, 'book-id': 1})
 434         self.assertEqual(res['error']['class'], 'GenericError')
 435
 436         res = self.vm.qmp('set-cpu-topology', {'core-id': 0, 'socket-id': 1})
 437         self.assertEqual(res['error']['class'], 'GenericError')
 438
 439         self.check_topology(0, 0, 0, 0, 'medium', False)