"""
Library to perform pre/post test setup for KVM autotest.
"""
import os, logging, time, re, random
from autotest_lib.client.common_lib import error
from autotest_lib.client.bin import utils
class THPError(Exception):
"""
Base exception for Transparent Hugepage setup.
"""
pass
class THPNotSupportedError(THPError):
"""
Thrown when host does not support tansparent hugepages.
"""
pass
class THPWriteConfigError(THPError):
"""
Thrown when host does not support tansparent hugepages.
"""
pass
class THPKhugepagedError(THPError):
"""
Thrown when khugepaged is not behaving as expected.
"""
pass
class TransparentHugePageConfig(object):
def __init__(self, test, params):
"""
Find paths for transparent hugepages and kugepaged configuration. Also,
back up original host configuration so it can be restored during
cleanup.
"""
self.params = params
RH_THP_PATH = "/sys/kernel/mm/redhat_transparent_hugepage"
UPSTREAM_THP_PATH = "/sys/kernel/mm/transparent_hugepage"
if os.path.isdir(RH_THP_PATH):
self.thp_path = RH_THP_PATH
elif os.path.isdir(UPSTREAM_THP_PATH):
self.thp_path = UPSTREAM_THP_PATH
else:
raise THPNotSupportedError("System doesn't support transparent "
"hugepages")
tmp_list = []
test_cfg = {}
test_config = self.params.get("test_config", None)
if test_config is not None:
tmp_list = re.split(';', test_config)
while len(tmp_list) > 0:
tmp_cfg = tmp_list.pop()
test_cfg[re.split(":", tmp_cfg)[0]] = re.split(":", tmp_cfg)[1]
# Save host current config, so we can restore it during cleanup
# We will only save the writeable part of the config files
original_config = {}
# List of files that contain string config values
self.file_list_str = []
# List of files that contain integer config values
self.file_list_num = []
for f in os.walk(self.thp_path):
base_dir = f[0]
if f[2]:
for name in f[2]:
f_dir = os.path.join(base_dir, name)
parameter = file(f_dir, 'r').read()
try:
# Verify if the path in question is writable
f = open(f_dir, 'w')
f.close()
if re.findall("\[(.*)\]", parameter):
original_config[f_dir] = re.findall("\[(.*)\]",
parameter)[0]
self.file_list_str.append(f_dir)
else:
original_config[f_dir] = int(parameter)
self.file_list_num.append(f_dir)
except IOError:
pass
self.test_config = test_cfg
self.original_config = original_config
def set_env(self):
"""
Applies test configuration on the host.
"""
if self.test_config:
for path in self.test_config.keys():
file(path, 'w').write(self.test_config[path])
def value_listed(self, value):
"""
Get a parameters list from a string
"""
value_list = []
for i in re.split("\[|\]|\n+|\s+", value):
if i:
value_list.append(i)
return value_list
def khugepaged_test(self):
"""
Start, stop and frequency change test for khugepaged.
"""
def check_status_with_value(action_list, file_name):
"""
Check the status of khugepaged when set value to specify file.
"""
for (a, r) in action_list:
open(file_name, "w").write(a)
time.sleep(5)
try:
utils.run('pgrep khugepaged')
if r != 0:
raise THPKhugepagedError("Khugepaged still alive when"
"transparent huge page is "
"disabled")
except error.CmdError:
if r == 0:
raise THPKhugepagedError("Khugepaged could not be set to"
"status %s" % a)
for file_path in self.file_list_str:
action_list = []
if re.findall("enabled", file_path):
# Start and stop test for khugepaged
value_list = self.value_listed(open(file_path,"r").read())
for i in value_list:
if re.match("n", i, re.I):
action_stop = (i, 256)
for i in value_list:
if re.match("[^n]", i, re.I):
action = (i, 0)
action_list += [action_stop, action, action_stop]
action_list += [action]
check_status_with_value(action_list, file_path)
else:
value_list = self.value_listed(open(file_path,"r").read())
for i in value_list:
action = (i, 0)
action_list.append(action)
check_status_with_value(action_list, file_path)
for file_path in self.file_list_num:
action_list = []
value = int(open(file_path, "r").read())
if value != 0 and value != 1:
new_value = random.random()
action_list.append((str(int(value * new_value)),0))
action_list.append((str(int(value * ( new_value + 1))),0))
else:
action_list.append(("0", 0))
action_list.append(("1", 0))
check_status_with_value(action_list, file_path)
def setup(self):
"""
Configure host for testing. Also, check that khugepaged is working as
expected.
"""
self.set_env()
self.khugepaged_test()
def cleanup(self):
""":
Restore the host's original configuration after test
"""
for path in self.original_config:
p_file = open(path, 'w')
p_file.write(str(self.original_config[path]))
p_file.close()
class HugePageConfig(object):
def __init__(self, params):
"""
Gets environment variable values and calculates the target number
of huge memory pages.
@param params: Dict like object containing parameters for the test.
"""
self.vms = len(params.objects("vms"))
self.mem = int(params.get("mem"))
self.max_vms = int(params.get("max_vms", 0))
self.hugepage_path = '/mnt/kvm_hugepage'
self.hugepage_size = self.get_hugepage_size()
self.target_hugepages = self.get_target_hugepages()
self.kernel_hp_file = '/proc/sys/vm/nr_hugepages'
def get_hugepage_size(self):
"""
Get the current system setting for huge memory page size.
"""
meminfo = open('/proc/meminfo', 'r').readlines()
huge_line_list = [h for h in meminfo if h.startswith("Hugepagesize")]
try:
return int(huge_line_list[0].split()[1])
except ValueError, e:
raise ValueError("Could not get huge page size setting from "
"/proc/meminfo: %s" % e)
def get_target_hugepages(self):
"""
Calculate the target number of hugepages for testing purposes.
"""
if self.vms < self.max_vms:
self.vms = self.max_vms
# memory of all VMs plus qemu overhead of 64MB per guest
vmsm = (self.vms * self.mem) + (self.vms * 64)
return int(vmsm * 1024 / self.hugepage_size)
@error.context_aware
def set_hugepages(self):
"""
Sets the hugepage limit to the target hugepage value calculated.
"""
error.context("setting hugepages limit to %s" % self.target_hugepages)
hugepage_cfg = open(self.kernel_hp_file, "r+")
hp = hugepage_cfg.readline()
while int(hp) < self.target_hugepages:
loop_hp = hp
hugepage_cfg.write(str(self.target_hugepages))
hugepage_cfg.flush()
hugepage_cfg.seek(0)
hp = int(hugepage_cfg.readline())
if loop_hp == hp:
raise ValueError("Cannot set the kernel hugepage setting "
"to the target value of %d hugepages." %
self.target_hugepages)
hugepage_cfg.close()
logging.debug("Successfuly set %s large memory pages on host ",
self.target_hugepages)
@error.context_aware
def mount_hugepage_fs(self):
"""
Verify if there's a hugetlbfs mount set. If there's none, will set up
a hugetlbfs mount using the class attribute that defines the mount
point.
"""
error.context("mounting hugepages path")
if not os.path.ismount(self.hugepage_path):
if not os.path.isdir(self.hugepage_path):
os.makedirs(self.hugepage_path)
cmd = "mount -t hugetlbfs none %s" % self.hugepage_path
utils.system(cmd)
def setup(self):
logging.debug("Number of VMs this test will use: %d", self.vms)
logging.debug("Amount of memory used by each vm: %s", self.mem)
logging.debug("System setting for large memory page size: %s",
self.hugepage_size)
logging.debug("Number of large memory pages needed for this test: %s",
self.target_hugepages)
self.set_hugepages()
self.mount_hugepage_fs()
@error.context_aware
def cleanup(self):
error.context("trying to dealocate hugepage memory")
try:
utils.system("umount %s" % self.hugepage_path)
except error.CmdError:
return
utils.system("echo 0 > %s" % self.kernel_hp_file)
logging.debug("Hugepage memory successfuly dealocated")