Numa memdev options test:

    1. Add new cases for testing numa memdev options(with mlock, policy, hugepage)
    2. Update mlock_basic
Signed-off-by: Nyduan <yduan@redhat.com>

qemu/tests/cfg/mlock_basic.cfg

@@ -2,8 +2,6 @@
     virt_test_type = qemu
     type = mlock_basic
     start_vm = no
-    mlock_cmd = "grep nr_mlock /proc/vmstat"
-    unevictable_cmd = "grep nr_unevictable /proc/vmstat"
     variants:
         - mlock_on:
             realtime_mlock = on

qemu/tests/cfg/numa_memdev_options.cfg

+- numa_memdev_options:
+    type = numa_memdev_options
+    kill_vm_on_error = yes
+    mem_fixed = 1536
+    mem_devs = "mem0 mem1"
+    backend_mem = memory-backend-ram
+    use_mem = no
+    host-nodes_mem0 = 0
+    host-nodes_mem1 = 1
+    size_mem0 = 512M
+    size_mem1 = 1024M
+    guest_numa_nodes = "node0 node1"
+    numa_memdev_node0 = mem-mem0
+    numa_memdev_node1 = mem-mem1
+    variants:
+        - prealloc:
+            prealloc_mem0 = yes
+            prealloc_mem1 = yes
+        - no_prealloc:
+            prealloc_mem0 = no
+            prealloc_mem1 = no
+    variants:
+        - policy_default:
+            policy_mem = default
+            del host-nodes_mem0
+            del host-nodes_mem1
+        - policy_bind:
+            policy_mem = bind
+        - policy_interleave:
+            policy_mem = interleave
+        - policy_preferred:
+            policy_mem = preferred
+    variants:
+        - numa_policy:
+        - numa_mlock:
+            type = numa_memdev_mlock
+            realtime_mlock = on
+            start_vm = no
+        - numa_hugepage:
+            backend_mem = memory-backend-file
+            setup_hugepages = yes
+            mem-path = /mnt/kvm_hugepage
+            target_hugepages = 1500

qemu/tests/mlock_basic.py

 import logging
 from resource import getpagesize
 
-from avocado.utils import process
-
 from virttest import env_process
 from virttest import error_context
+from virttest.staging.utils_memory import read_from_vmstat
+
+
+class MlockBasic(object):
+    """
+    Base class for mlock test
+    """
+    def __init__(self, test, params, env):
+        self.test = test
+        self.params = params
+        self.env = env
+        self.realtime_mlock = params["realtime_mlock"]
+        self.vm_mem = int(params["mem"])
+        self.vm = None
+        self.mlock_pre = None
+        self.mlock_post = None
+        self.unevictable_pre = None
+        self.unevictable_post = None
+
+    def _check_mlock_unevictable(self):
+        """
+        Check nr_mlock and nr_unevictable with guest memory
+        """
+        if self.realtime_mlock == "on":
+            vm_pages = self.vm_mem * 1024 * 1024 / getpagesize()
+            nr_mlock = self.mlock_post - self.mlock_pre
+            nr_unevictable = self.unevictable_post - self.unevictable_pre
+            if nr_mlock < vm_pages:
+                self.test.fail("nr_mlock is not fit with VM memory"
+                               " when mlock is %s!"
+                               " nr_mlock = %d, vm_mem = %d."
+                               % (self.realtime_mlock, nr_mlock, self.vm_mem))
+            if nr_unevictable < vm_pages:
+                self.test.fail("nr_unevictable is not fit with VM memory"
+                               " when mlock is %s!"
+                               " nr_unevictable = %d, vm_mem = %d."
+                               % (self.realtime_mlock, nr_unevictable,
+                                  self.vm_mem))
+        else:
+            if self.mlock_post != self.mlock_pre:
+                self.test.fail("mlock_post != mlock_pre when mlock is %s!"
+                               % self.realtime_mlock)
+            if self.unevictable_post != self.unevictable_pre:
+                self.test.fail("unevictable_post != unevictable_pre"
+                               " when mlock is %s!"
+                               % self.realtime_mlock)
+
+    def start(self):
+        """
+        Start mlock basic test
+        """
+        error_context.context("Get nr_mlock and nr_unevictable in host"
+                              " before VM start!", logging.info)
+        self.mlock_pre = read_from_vmstat("nr_mlock")
+        self.unevictable_pre = read_from_vmstat("nr_unevictable")
+        logging.info("mlock_pre is %d and unevictable_pre is %d.",
+                     self.mlock_pre, self.unevictable_pre)
+        self.params["start_vm"] = "yes"
+
+        error_context.context("Starting VM!", logging.info)
+        env_process.preprocess_vm(self.test, self.params,
+                                  self.env, self.params["main_vm"])
+        self.vm = self.env.get_vm(self.params["main_vm"])
+        self.vm.verify_alive()
+
+        error_context.context("Get nr_mlock and nr_unevictable in host"
+                              " after VM start!", logging.info)
+        self.mlock_post = read_from_vmstat("nr_mlock")
+        self.unevictable_post = read_from_vmstat("nr_unevictable")
+        logging.info("mlock_post is %d and unevictable_post is %d.",
+                     self.mlock_post, self.unevictable_post)
+
+        self._check_mlock_unevictable()
 
 
 @error_context.context_aware
@@ -21,52 +92,8 @@ def run(test, params, env):
     :param params: Dictionary with the test parameters
     :param env: Dictionary with test environment.
     """
-
-    def get_mlock_unevictable(mlock_cmd, unevictable_cmd):
-        """
-        Get nr_mlock and nr_unevictable in host
-
-        :param mlock_cmd: CMD to get nr_mlock
-        :param unevictable_cmd: CMD to get nr_unevictable
-        """
-        mlock = int(process.system_output(mlock_cmd).split().pop())
-        unevictable = int(process.system_output(unevictable_cmd).split().pop())
-        return mlock, unevictable
-
-    mlock_cmd = params["mlock_cmd"]
-    unevictable_cmd = params["unevictable_cmd"]
-    vm_mem = int(params["mem"])
-
-    error_context.context("Get nr_mlock and nr_unevictable in host before VM start!", logging.info)
-    mlock_pre, unevictable_pre = get_mlock_unevictable(mlock_cmd, unevictable_cmd)
-    logging.info("mlock_pre is %d and unevictable_pre is %d.", mlock_pre, unevictable_pre)
-    params["start_vm"] = "yes"
-
-    error_context.context("Starting VM!", logging.info)
-    env_process.preprocess_vm(test, params, env, params["main_vm"])
-    vm = env.get_vm(params["main_vm"])
-    vm.verify_alive()
-
-    error_context.context("Get nr_mlock and nr_unevictable in host after VM start!", logging.info)
-    mlock_post, unevictable_post = get_mlock_unevictable(mlock_cmd, unevictable_cmd)
-    logging.info("mlock_post is %d and unevictable_post is %d.", mlock_post, unevictable_post)
-
-    realtime_mlock = params["realtime_mlock"]
-    if realtime_mlock == "on":
-        nr_mlock = mlock_post - mlock_pre
-        vm_pages = vm_mem * 1024 * 1024 / getpagesize()
-        if nr_mlock < vm_pages:
-            test.fail("nr_mlock is not fit with VM memory when mlock is %s! nr_mlock = %d, vm_mem = %d."
-                      % (realtime_mlock, nr_mlock, vm_mem))
-        nr_unevictable = unevictable_post - unevictable_pre
-        if nr_unevictable < vm_pages:
-            test.fail("nr_unevictable is not fit with VM memory when mlock is %s! nr_unevictable = %d, vm_mem = %d."
-                      % (realtime_mlock, nr_unevictable, vm_mem))
-    else:
-        if mlock_post != mlock_pre:
-            test.fail("mlock_post is not equal to mlock_pre when mlock is %s!" % realtime_mlock)
-        if unevictable_post != unevictable_pre:
-            test.fail("unevictable_post is not equal to unevictable_pre when mlock is %s!" % realtime_mlock)
+    mlock_test = MlockBasic(test, params, env)
+    mlock_test.start()
 
     error_context.context("Check kernel crash message!", logging.info)
-    vm.verify_kernel_crash()
+    mlock_test.vm.verify_kernel_crash()

qemu/tests/numa_memdev_mlock.py

+import logging
+
+from virttest import error_context
+
+from qemu.tests import numa_memdev_options
+from qemu.tests.mlock_basic import MlockBasic
+
+
+@error_context.context_aware
+def run(test, params, env):
+    """
+    [Memory][Numa] NUMA memdev option test with mlock, this case will:
+    1) Check host's numa node(s) amount.
+    2) Get nr_mlock and nr_unevictable in host before VM start.
+    3) Start the VM.
+    4) Get nr_mlock and nr_unevictable in host after VM start.
+    5) Check nr_mlock and nr_unevictable with VM memory.
+    6) Check the policy.
+    7) Check the memory in procfs.
+
+    :param test: QEMU test object
+    :param params: Dictionary with the test parameters
+    :param env: Dictionary with test environment.
+    """
+    error_context.context("Check host's numa node(s) amount!", logging.info)
+    numa_memdev_options.check_host_numa_node_amount(test)
+
+    numa_mlock_test = MlockBasic(test, params, env)
+    numa_mlock_test.start()
+
+    error_context.context("Check query-memdev!", logging.info)
+    numa_memdev_options.check_query_memdev(test, params, numa_mlock_test.vm)
+
+    error_context.context("Check the memory in procfs!", logging.info)
+    numa_memdev_options.check_memory_in_procfs(test, params, numa_mlock_test.vm)

qemu/tests/numa_memdev_options.py

+import logging
+
+from avocado.utils import process
+
+from virttest import error_context
+from virttest import utils_misc
+from virttest.staging import utils_memory
+
+
+def check_host_numa_node_amount(test):
+    """
+    Check host NUMA node amount
+
+    :param test: QEMU test object
+    """
+    host_numa_nodes = utils_memory.numa_nodes()
+    host_numa_nodes = len(host_numa_nodes)
+    if host_numa_nodes < 2:
+        test.cancel("The host numa nodes should be at least 2! But there is %d."
+                    % host_numa_nodes)
+
+
+def check_query_memdev(test, params, vm):
+    """
+    Check memory info in query-memdev
+
+    :param test: QEMU test object
+    :param params: Dictionary with the test parameters
+    :param vm: VM object
+    """
+    mem_devs = params['mem_devs'].split()
+    query_list = vm.monitor.info("memdev")
+    if len(mem_devs) != len(query_list):
+        test.fail("%d memory devices in query-memdev, but not %d!"
+                  " query-memdev: %s"
+                  % (len(query_list), len(mem_devs),
+                     [item["id"] for item in query_list]))
+    policy = params['policy_mem']
+    for dev in query_list:
+        mem_dev = dev['id'].split('-')[1]
+        memdev_params = params.object_params(mem_dev)
+        if dev['policy'] != policy:
+            test.fail("memdev = %s: 'policy' is '%s', but not '%s'!"
+                      % (mem_dev, dev['policy'], policy))
+        prealloc = (memdev_params['prealloc'] == 'yes')
+        if dev['prealloc'] != prealloc:
+            test.fail("memdev = %s: 'prealloc' is not '%s'!"
+                      % (mem_dev, memdev_params['prealloc']))
+        if policy == 'default':
+            continue
+        host_node = str(dev['host-nodes'][0])
+        if host_node != memdev_params['host-nodes']:
+            test.fail("memdev = %s: 'host-nodes' is '%s', but not '%s'!"
+                      % (mem_dev, host_node, memdev_params["host-nodes"]))
+
+
+def check_memory_in_procfs(test, params, vm):
+    """
+    Check memory info in procfs
+
+    :param test: QEMU test object
+    :param params: Dictionary with the test parameters
+    :param vm: VM object
+    """
+    qemu_pid = vm.get_pid()
+    policy = params['policy_mem']
+    if policy == 'preferred':
+        policy = 'prefer'
+    mem_path = params.get("mem-path", None)
+    for mem_dev in params['mem_devs'].split():
+        memdev_params = params.object_params(mem_dev)
+        mem_size = memdev_params['size']
+        mem_size = int(float(utils_misc.normalize_data_size(mem_size, "K")))
+        smaps = process.system_output("grep -1 %d /proc/%d/smaps"
+                                      % (mem_size, qemu_pid))
+        if mem_path and (mem_path not in smaps):
+            test.fail("memdev = %s: mem-path '%s' is not in smaps '%s'!"
+                      % (mem_dev, mem_path, smaps))
+        mem_start = smaps.split('-')[0]
+        numa_maps = process.system_output("grep %s /proc/%d/numa_maps"
+                                          % (mem_start, qemu_pid))
+        if mem_path and (mem_path not in numa_maps):
+            test.fail("memdev = %s: mem-path '%s' is not in numa_maps '%s'!"
+                      % (mem_dev, mem_path, numa_maps))
+        policy_numa = numa_maps.split()[1].split(':')
+        if policy != policy_numa[0]:
+            test.fail("memdev = %s:"
+                      " 'policy' in numa_maps is '%s', but not '%s'!"
+                      % (mem_dev, policy_numa[0], policy))
+        elif (policy != 'default'):
+            host_node = memdev_params['host-nodes']
+            if (policy_numa[1] != host_node):
+                test.fail("memdev = %s:"
+                          " 'host-nodes' in numa_maps is '%s', but not '%s'!"
+                          % (mem_dev, policy_numa[1], host_node))
+
+
+@error_context.context_aware
+def run(test, params, env):
+    """
+    [Memory][Numa] NUMA memdev option, this case will:
+    1) Check host's numa node(s) amount.
+    2) Start the VM.
+    3) Check query-memdev.
+    4) Check the memory in procfs.
+
+    :param test: QEMU test object
+    :param params: Dictionary with the test parameters
+    :param env: Dictionary with test environment
+    """
+    error_context.context("Check host's numa node(s) amount!", logging.info)
+    check_host_numa_node_amount(test)
+
+    error_context.context("Starting VM!", logging.info)
+    vm = env.get_vm(params["main_vm"])
+    vm.verify_alive()
+
+    error_context.context("Check query-memdev!", logging.info)
+    check_query_memdev(test, params, vm)
+
+    error_context.context("Check the memory in procfs!", logging.info)
+    check_memory_in_procfs(test, params, vm)