#! /usr/libexec/platform-python

from __future__ import print_function

from __future__ import division

import subprocess

import types

import os

import sys

import getopt

import resource

import errno

# The superset of wordsizes that should be tested (default 32, 64)

wordsizes = set()

# The super set of page sizes that should be tested.  Defaults to all supported

# huge page sizes with an active mount and at least one huge page allocated

pagesizes = set()

# Each page size may have a subset of valid wordsizes

# This is a dictionary (indexed by page size) of sets

wordsizes_by_pagesize = {}

# The linkhuge tests may only be valid on a subset of word sizes

# This set contains the wordsizes valid for linkhuge tests

linkhuge_wordsizes = set()

# A list of all discovered mountpoints that may be used by libhugetlbfs for

# this run of tests.  This is used for cleaning up left-over share files.

mounts = []

# Results matrix:  This 3-D dictionary is indexed as follows:

#   [type]     - Test results fall into one of the 'result_types' categories

#   [pagesize] - a page size from the set 'pagesizes'

#   [bits]     - a word size from the set 'wordsizes'

#   The indexed value is the number of tests matching the above traits

R = {}

result_types = ("total", "pass", "config", "fail", "xfail", "xpass",

                "signal", "strange", "skip", "nofile")

def bash(cmd):

    """

    Run 'cmd' in the shell and return the exit code and output.

    """

    p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)

    try:

        rc = p.wait()

    except KeyboardInterrupt:

        # Abort and mark this a strange test result

        return (127, "")

    out = p.stdout.read().decode().strip()

    return (rc, out)

def snapshot_pool_state():

    l = []

    for d in os.listdir("/sys/kernel/mm/hugepages"):

        substate = [(f, int(open("/sys/kernel/mm/hugepages/%s/%s" % (d, f)).read()))

                    for f in os.listdir("/sys/kernel/mm/hugepages/%s" % d)]

        l.append((d, tuple(substate)))

    return tuple(l)

def run_test_prog(bits, pagesize, cmd, **env):

    if paranoid_pool_check:

        beforepool = snapshot_pool_state()

        print("Pool state: %s" % str(beforepool))

    local_env = os.environ.copy()

    local_env.update(env)

    local_env["PATH"] = "./obj%d:../obj%d:%s" \

        % (bits, bits, local_env.get("PATH", ""))

    local_env["LD_LIBRARY_PATH"] = "../obj%d:obj%d:%s" \

        % (bits, bits, local_env.get("LD_LIBRARY_PATH", ""))

    local_env["HUGETLB_DEFAULT_PAGE_SIZE"] = repr(pagesize)

    try:

        p = subprocess.Popen(cmd, env=local_env, stdout=subprocess.PIPE)

        rc = p.wait()

    except KeyboardInterrupt:

        # Abort and mark this a strange test result

        return (None, "")

    except OSError as e:

        return (-e.errno, "")

    out = p.stdout.read().decode().strip()

    if paranoid_pool_check:

        afterpool = snapshot_pool_state()

        if afterpool != beforepool:

            print("Hugepage pool state not preserved!", file=sys.stderr)

            print("BEFORE: %s" % str(beforepool), file=sys.stderr)

            print("AFTER: %s" % str(afterpool), file=sys.stderr)

            sys.exit(98)

    return (rc, out)

def setup_env(override, defaults):

    """

    Set up the environment for running commands in the shell.

    """

    # All items in override are unconditionally set or unset

    for (var, val) in override.items():

        if val == None:

            if var in os.environ:

                del os.environ[var]

        else:

            os.environ[var] = val

    # If not already set, these variables are given default values

    for (var, val) in defaults.items():

        if var not in os.environ or os.environ[var] == "":

            os.environ[var] = val

def init_results():

    """

    Define the structure of the results matrix and initialize all results to 0.

    """

    global R

    for t in result_types:

        R[t] = {}

        for p in pagesizes:

            R[t][p] = {}

            for bits in (32, 64):

                R[t][p][bits] = 0

def pretty_page_size(size):

    """

    Convert a page size to a formatted string

    Given a page size in bytes, return a string that expresses the size in

    a sensible unit (K, M, or G).

    """

    factor = 0

    while size > 1024:

        factor += 1

        size /= 1024

    if   factor == 0: return "%iB" % size

    elif factor == 1: return "%iK" % size

    elif factor == 2: return "%iM" % size

    elif factor == 3: return "%iG" % size

def print_per_size(title, values):

    """

    Print one line of test results

    Print the results of a given result type on one line.  The results for all

    page sizes and word sizes are written in a table format.

    """

    print("*%20s: " % title, end=" ")

    for sz in pagesizes:

        print("%4s   %4s   " % (values[sz][32], values[sz][64]), end="")

    print()

def results_summary():

    """

    Display a summary of the test results

    """

    print("********** TEST SUMMARY")

    print("*%21s" % "", end=" ")

    for p in pagesizes:

        print("%-13s " % pretty_page_size(p), end="")

    print()

    print("*%21s" % "", end=" ")

    for p in pagesizes:

        print("32-bit 64-bit ", end="")

    print()

    print_per_size("Total testcases", R["total"])

    print_per_size("Skipped", R["skip"])

    print_per_size("PASS", R["pass"])

    print_per_size("FAIL", R["fail"])

    print_per_size("Killed by signal", R["signal"])

    print_per_size("Bad configuration", R["config"])

    print_per_size("Expected FAIL", R["xfail"])

    print_per_size("Unexpected PASS", R["xpass"])

    print_per_size("Test not present", R["nofile"])

    print_per_size("Strange test result", R["strange"])

    print("**********")

def free_hpages(size=None):

    """

    Return the number of free huge pages for a given size. If size is not

    passed, use the default huge page size.

    Parse /sys/kernel/mm/hugepages/hugepages-<size-in-kB>/free_hugepages to

    obtain the number of free huge pages for the given page size.

    """

    if size == None: size = system_default_hpage_size

    size_kb = size / 1024

    cmd = "cat /sys/kernel/mm/hugepages/hugepages-%dkB/free_hugepages" % size_kb

    (rc, out) = bash(cmd)

    return (rc, int(out))

def total_hpages(size=None):

    """

    Return the total number of huge pages in the pool for a given size. If

    size is not passed, use the default huge page size.

    Parse /sys/kernel/mm/hugepages/hugepages-<size-in-kB>/nr_hugepages to

    obtain the number of huge pages for the given page size.

    """

    if size == None: size = system_default_hpage_size

    size_kb = size / 1024

    cmd = "cat /sys/kernel/mm/hugepages/hugepages-%dkB/nr_hugepages" % size_kb

    (rc, out) = bash(cmd)

    return (rc, int(out))

def hpage_size():

    """

    Return the size of the default huge page size in bytes.

    Parse /proc/meminfo to obtain the default huge page size.  This number is

    reported in Kb so multiply it by 1024 to convert it to bytes.

    XXX: This function is not multi-size aware yet.

    """

    (rc, out) = bash("grep 'Hugepagesize:' /proc/meminfo | awk '{print $2}'")

    if out == "": out = 0

    out = int(out) * 1024

    return (rc, out)

def clear_hpages():

    """

    Remove stale hugetlbfs files after sharing tests.

    Traverse the mount points that are in use during testing to find left-over

    files that were created by the elflink sharing tests.  These are not

    cleaned up automatically and must be removed to free up the huge pages.

    """

    for mount in mounts:

        dir = mount + "/elflink-uid-" + repr(os.getuid())

        for root, dirs, files in os.walk(dir, topdown=False):

            for name in files:

                os.remove(os.path.join(root, name))

            for name in dirs:

                os.rmdir(os.path.join(root, name))

        try:

            os.rmdir(dir)

        except OSError:

            pass

def get_pagesizes():

    """

    Get a list of configured huge page sizes.

    Use libhugetlbfs' hugeadm utility to get a list of page sizes that have

    active mount points and at least one huge page allocated to the pool.

    """

    sizes = set()

    out = ""

    (rc, out) = bash("hugeadm --page-sizes")

    if rc != 0 or out == "":

        return sizes

    for size in out.split("\n"):

        sizes.add(int(size))

    return sizes

def get_wordsizes():

    """

    Checks for obj32 and obj64 subdirs to determine valid word sizes.

    """

    sizes = set()

    if os.path.isdir("./obj32"): sizes.add(32)

    if os.path.isdir("./obj64"): sizes.add(64)

    return sizes

def check_hugetlbfs_path():

    """

    Check each combination of page size and word size for validity.

    Some word sizes may not be valid for all page sizes.  For example, a 16G

    page is too large to be used in a 32 bit process.  Use a helper program to

    weed out invalid combinations and print informational messages as required.

    """

    global wordsizes, pagesizes, mounts, wordsizes_by_pagesize

    for p in pagesizes:

        okbits = []

        for b in wordsizes:

            (rc, out) = run_test_prog(b, p, "get_hugetlbfs_path")

            if rc == 0:

                okbits.append(b)

                mounts.append(out)

        if len(okbits) == 0:

            print("run_tests.py: No mountpoints available for page size %s" %

                  pretty_page_size(p))

            wordsizes_by_pagesize[p] = set()

            continue

        for b in wordsizes - set(okbits):

            print("run_tests.py: The %i bit word size is not compatible with " \

                  "%s pages" % (b, pretty_page_size(p)))

        wordsizes_by_pagesize[p] = set(okbits)

def check_linkhuge_tests():

    """

    Check if the linkhuge tests are safe to run on this system.

    Newer versions of binutils (>= 2.18) are known to be incompatible with the

    linkhuge tests and running them may cause unreliable behavior.  Determine

    which word sizes can be tested with linkhuge.  The others will be skipped.

    NOTE: The linhuge_rw tests are always safe to run and will not be skipped.

    """

    okbits = set()

    for bits in wordsizes:

        script = open('obj%d/dummy.ldscript' % bits, 'r').read()

        if script.count('SPECIAL') == 0:

            okbits.add(bits)

    return okbits

def print_cmd(pagesize, bits, cmd, env):

    if env:

        print(' '.join(['%s=%s' % (k, v) for k, v in env.items()]), end=" ")

    if not isinstance(cmd, str):

        cmd = ' '.join(cmd)

    print("%s (%s: %i):\t" % (cmd, pretty_page_size(pagesize), bits), end="")

    sys.stdout.flush()

def run_test(pagesize, bits, cmd, **env):

    """

    Execute a test, print the output and log the result

    Run a test using the specified page size and word size.  The parameter

    'pre' may contain additional environment settings and will be prepended to

    cmd.  A line showing info about the test is printed and after completion

    the test output is printed.  The result is recorded in the result matrix.

    """

    global R

    objdir = "obj%i" % bits

    if not os.path.isdir(objdir):

        return

    print_cmd(pagesize, bits, cmd, env)

    (rc, out) = run_test_prog(bits, pagesize, cmd, **env)

    print(out)

    R["total"][pagesize][bits] += 1

    if rc == 0:    R["pass"][pagesize][bits] += 1

    elif rc == 1:  R["config"][pagesize][bits] += 1

    elif rc == 2:  R["fail"][pagesize][bits] += 1

    elif rc == 3:  R["xfail"][pagesize][bits] += 1

    elif rc == 4:  R["xpass"][pagesize][bits] += 1

    elif rc == -errno.ENOENT:

                   R["nofile"][pagesize][bits] += 1

    elif rc < 0:   R["signal"][pagesize][bits] += 1

    else:          R["strange"][pagesize][bits] += 1

def skip_test(pagesize, bits, cmd, **env):

    """

    Skip a test, print test information, and log that it was skipped.

    """

    global tot_tests, tot_skip

    R["total"][pagesize][bits] += 1

    R["skip"][pagesize][bits] += 1

    print_cmd(pagesize, bits, cmd, env)

    print("SKIPPED")

def do_test(cmd, bits=None, **env):

    """

    Run a test case, testing each page size and each indicated word size.

    """

    if bits == None: bits = wordsizes

    for p in pagesizes:

        for b in (set(bits) & wordsizes_by_pagesize[p]):

            run_test(p, b, cmd, **env)

def do_test_with_rlimit(rtype, limit, cmd, bits=None, **env):

    """

    Run a test case with a temporarily altered resource limit.

    """

    oldlimit = resource.getrlimit(rtype)

    resource.setrlimit(rtype, (limit, limit))

    do_test(cmd, bits, **env)

    resource.setrlimit(rtype, oldlimit)

def do_test_with_pagesize(pagesize, cmd, bits=None, **env):

    """

    Run a test case, testing with a specified huge page size and

    each indicated word size.

    """

    if bits == None:

        bits = wordsizes

    for b in (set(bits) & wordsizes_by_pagesize[pagesize]):

        run_test(pagesize, b, cmd, **env)

def do_elflink_test(cmd, **env):

    """

    Run an elflink test case, skipping known-bad configurations.

    """

    for b in wordsizes_by_pagesize[system_default_hpage_size]:

        if b in linkhuge_wordsizes:

            run_test(system_default_hpage_size, b, cmd, **env)

        else:

            skip_test(system_default_hpage_size, b, cmd, **env)

def elflink_test(cmd, **env):

    """

    Run an elflink test case with different configuration combinations.

    Test various combinations of: preloading libhugetlbfs, B vs. BDT link

    modes, minimal copying on or off, and disabling segment remapping.

    """

    do_test_with_pagesize(system_default_hpage_size, cmd, **env)

    # Test we don't blow up if not linked for hugepage

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          LD_PRELOAD="libhugetlbfs.so", **env)

    # Only run custom ldscript tests when -l option is set

    if not custom_ldscripts:

        return

    do_elflink_test("xB." + cmd, **env)

    do_elflink_test("xBDT." + cmd, **env)

    # Test we don't blow up if HUGETLB_MINIMAL_COPY is diabled

    do_elflink_test("xB." + cmd, HUGETLB_MINIMAL_COPY="no", **env)

    do_elflink_test("xBDT." + cmd, HUGETLB_MINIMAL_COPY="no", **env)

    # Test that HUGETLB_ELFMAP=no inhibits remapping as intended

    do_elflink_test("xB." + cmd, HUGETLB_ELFMAP="no", **env)

    do_elflink_test("xBDT." + cmd, HUGETLB_ELFMAP="no", **env)

def elflink_rw_test(cmd, **env):

    """

    Run the elflink_rw test with different configuration combinations.

    Test various combinations of: remapping modes and minimal copy on or off.

    """

    # Basic tests: None, Read-only, Write-only, Read-Write, exlicit disable

    do_test_with_pagesize(system_default_hpage_size, cmd, **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_ELFMAP="R", **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_ELFMAP="W", **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_ELFMAP="RW", **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_ELFMAP="no", **env)

    # Test we don't blow up if HUGETLB_MINIMAL_COPY is disabled

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_MINIMAL_COPY="no", HUGETLB_ELFMAP="R", **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_MINIMAL_COPY="no", HUGETLB_ELFMAP="W", **env)

    do_test_with_pagesize(system_default_hpage_size, cmd,

                          HUGETLB_MINIMAL_COPY="no", HUGETLB_ELFMAP="RW", **env)

def elfshare_test(cmd, **env):

    """

    Test segment sharing with multiple configuration variations.

    """

    # Run each elfshare test invocation independently - clean up the

    # sharefiles before and after in the first set of runs, but leave

    # them there in the second:

    clear_hpages()

    do_elflink_test("xB." + cmd, HUGETLB_SHARE="1", **env)

    clear_hpages()

    do_elflink_test("xBDT." + cmd, HUGETLB_SHARE="1", **env)

    clear_hpages()

    do_elflink_test("xB." + cmd, HUGETLB_SHARE="1", **env)

    do_elflink_test("xBDT." + cmd, HUGETLB_SHARE="1", **env)

    clear_hpages()

def elflink_and_share_test(cmd, **env):

    """

    Run the ordinary linkhuge tests with sharing enabled

    """

    # Run each elflink test pair independently - clean up the sharefiles

    # before and after each pair

    clear_hpages()

    for link_str in ("xB.", "xBDT."):

        for i in range(2):

            do_elflink_test(link_str + cmd, HUGETLB_SHARE=repr(i), **env)

        clear_hpages()

def elflink_rw_and_share_test(cmd, **env):

    """

    Run the ordinary linkhuge_rw tests with sharing enabled

    """

    clear_hpages()

    for mode in ("R", "W", "RW"):

        for i in range(2):

            do_test_with_pagesize(system_default_hpage_size, cmd,

                                  HUGETLB_ELFMAP=mode, HUGETLB_SHARE=repr(i),

                                  **env)

        clear_hpages()

def setup_shm_sysctl(limit):

    """

    Adjust the kernel shared memory limits to accomodate a desired size.

    The original values are returned in a dictionary that can be passed to

    restore_shm_sysctl() to restore the system state.

    """

    if os.getuid() != 0: return {}

    sysctls = {}

    files = [ "/proc/sys/kernel/shmmax", "/proc/sys/kernel/shmall"]

    for f in files:

        fh = open(f, "r")

        sysctls[f] = fh.read()

        fh.close()

        fh = open(f, "w")

        fh.write(repr(limit))

        fh.close()

    print("set shmmax limit to %s" % limit)

    return sysctls

def restore_shm_sysctl(sysctls):

    """

    Restore the sysctls named in 'sysctls' to the given values.

    """

    if os.getuid() != 0: return

    for (file, val) in sysctls.items():

        fh = open(file, "w")

        fh.write(val)

        fh.close()

def do_shm_test(cmd, limit=None, bits=None, **env):

    """

    Run a test case with temporarily expanded SysV shm limits, testing

    each indicated word size.

    """

    if bits == None:

        bits = wordsizes

    if limit != None:

        tmp = setup_shm_sysctl(limit)

    for b in bits:

        run_test(system_default_hpage_size, b, cmd, **env)

    if limit != None:

        restore_shm_sysctl(tmp)

def functional_tests():

    """

    Run the set of functional tests.

    """

    global linkhuge_wordsizes

    # Kernel background tests not requiring hugepage support

    do_test("zero_filesize_segment")

    # Library background tests not requiring hugepage support

    do_test("test_root")

    do_test("meminfo_nohuge")

    # Library tests requiring kernel hugepage support

    do_test("gethugepagesize")

    do_test("gethugepagesizes")

    do_test("empty_mounts", HUGETLB_VERBOSE="1")

    do_test("large_mounts", HUGETLB_VERBOSE="1")

    # Tests requiring an active and usable hugepage mount

    do_test("find_path")

    do_test("unlinked_fd")

    do_test("readback")

    do_test("truncate")

    do_test("shared")

    do_test("mprotect")

    do_test_with_rlimit(resource.RLIMIT_MEMLOCK, -1, "mlock")

    do_test("misalign")

    do_test("fallocate_basic.sh")

    do_test("fallocate_align.sh")

    # Specific kernel bug tests

    do_test("ptrace-write-hugepage")

    do_test("icache-hygiene")

    do_test("slbpacaflush")

    do_test("straddle_4GB_static", bits=(64,))

    do_test("huge_at_4GB_normal_below_static", bits=(64,))

    do_test("huge_below_4GB_normal_above_static", bits=(64,))

    do_test("map_high_truncate_2")

    do_test("misaligned_offset")

    do_test("truncate_above_4GB")

    do_test("brk_near_huge")

    do_test("task-size-overrun")

    do_test_with_rlimit(resource.RLIMIT_STACK, -1, "stack_grow_into_huge")

    do_test("corrupt-by-cow-opt")

    do_test("noresv-preserve-resv-page")

    do_test("noresv-regarded-as-resv")

    if dangerous == 1:

        do_test("readahead_reserve")

        do_test("madvise_reserve")

        do_test("fadvise_reserve")

        do_test("mremap-expand-slice-collision")

        do_test("mremap-fixed-normal-near-huge")

        do_test("mremap-fixed-huge-near-normal")

    else:

        do_test("readahead_reserve.sh")

        do_test("madvise_reserve.sh")

        do_test("fadvise_reserve.sh")

        do_test("mremap-expand-slice-collision.sh")

        do_test("mremap-fixed-normal-near-huge.sh")

        do_test("mremap-fixed-huge-near-normal.sh")

    do_shm_test("shm-perms", 1024*1024*1024)

    # Tests requiring an active mount and hugepage COW

    do_test("private")

    do_test("fork-cow")

    do_test("direct")

    do_test_with_pagesize(system_default_hpage_size, "malloc")

    do_test_with_pagesize(system_default_hpage_size, "malloc",

                          LD_PRELOAD="libhugetlbfs.so",

                          HUGETLB_MORECORE="yes")

    do_test_with_pagesize(system_default_hpage_size, "malloc",

                          LD_PRELOAD="libhugetlbfs.so",

                          HUGETLB_MORECORE="yes",

                          HUGETLB_RESTRICT_EXE="unknown:none")

    do_test_with_pagesize(system_default_hpage_size, "malloc",

                          LD_PRELOAD="libhugetlbfs.so",

                          HUGETLB_MORECORE="yes",

                          HUGETLB_RESTRICT_EXE="unknown:malloc")

    do_test_with_pagesize(system_default_hpage_size, "malloc_manysmall")

    do_test_with_pagesize(system_default_hpage_size, "malloc_manysmall",

                          LD_PRELOAD="libhugetlbfs.so",

                          HUGETLB_MORECORE="yes")

    # After upstream commit: (glibc-2.25.90-688-gd5c3fafc43) glibc has a

    # new per-thread caching mechanism that will NOT allow heapshrink test to

    # successfully measure if heap has shrunk or not due to the fact that

    # heap won't have its sized reduced right away.

    #

    # In order to disable it, you need to have the tunable GLIBC in place.

    # Unfortunately, it requires to be set before program is loaded, as an

    # environment variable, since we can't re-initialize malloc() from the

    # program context (not even with a constructor function), and the tunable

    # is only evaluated during malloc() initialization.

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0")

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0",

                          LD_PRELOAD="libheapshrink.so")

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0",

                          LD_PRELOAD="libhugetlbfs.so",

                          HUGETLB_MORECORE="yes")

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0",

                          LD_PRELOAD="libhugetlbfs.so libheapshrink.so",

                          HUGETLB_MORECORE="yes")

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0",

                          LD_PRELOAD="libheapshrink.so",

                          HUGETLB_MORECORE="yes",

                          HUGETLB_MORECORE_SHRINK="yes")

    do_test_with_pagesize(system_default_hpage_size, "heapshrink",

                          GLIBC_TUNABLES="glibc.malloc.tcache_count=0",

                          LD_PRELOAD="libhugetlbfs.so libheapshrink.so",

                          HUGETLB_MORECORE="yes",

                          HUGETLB_MORECORE_SHRINK="yes")

    do_test("heap-overflow", HUGETLB_VERBOSE="1", HUGETLB_MORECORE="yes")

    # Run the remapping tests' up-front checks

    linkhuge_wordsizes = check_linkhuge_tests()

    # Original elflink tests

    elflink_test("linkhuge_nofd", HUGETLB_VERBOSE="0")

    elflink_test("linkhuge")

    # Only run custom ldscript tests when -l option is set

    if custom_ldscripts:

        # Original elflink sharing tests

        elfshare_test("linkshare")

        elflink_and_share_test("linkhuge")

    # elflink_rw tests

    elflink_rw_test("linkhuge_rw")

    # elflink_rw sharing tests

    elflink_rw_and_share_test("linkhuge_rw")

    # Accounting bug tests

    # reset free hpages because sharing will have held some

    # alternatively, use

    do_test("chunk-overcommit")

    do_test(("alloc-instantiate-race", "shared"))

    do_test(("alloc-instantiate-race", "private"))

    do_test("truncate_reserve_wraparound")

    do_test("truncate_sigbus_versus_oom")

    # Test direct allocation API

    do_test("get_huge_pages")

    # Test overriding of shmget()

    do_shm_test("shmoverride_linked")

    do_shm_test("shmoverride_linked", HUGETLB_SHM="yes")

    do_shm_test("shmoverride_linked_static")

    do_shm_test("shmoverride_linked_static", HUGETLB_SHM="yes")

    do_shm_test("shmoverride_unlinked", LD_PRELOAD="libhugetlbfs.so")

    do_shm_test("shmoverride_unlinked", LD_PRELOAD="libhugetlbfs.so", HUGETLB_SHM="yes")

    # Test hugetlbfs filesystem quota accounting

    do_test("quota.sh")

    # Test accounting of HugePages_{Total|Free|Resv|Surp}

    #  Alters the size of the hugepage pool so should probably be run last

    do_test("counters.sh")

def stress_tests():

    """

    Run the set of stress tests.

    """

    iterations = 10	# Number of iterations for looping tests

    # Don't update NRPAGES every time like above because we want to catch the

    # failures that happen when the kernel doesn't release all of the huge pages

    # after a stress test terminates

    nr_pages = {p: free_hpages(p)[1] for p in pagesizes}

    for p in pagesizes:

        cmd = ("mmap-gettest", repr(iterations), repr(nr_pages[p]))

        do_test_with_pagesize(p, cmd)

    for p in pagesizes:

        # mmap-cow needs a hugepage for each thread plus one extra

        cmd = ("mmap-cow", repr(nr_pages[p]-1), repr(nr_pages[p]))

        do_test_with_pagesize(p, cmd)

    (rc, tot_pages) = total_hpages()

    nr_pages = nr_pages[system_default_hpage_size]

    limit = system_default_hpage_size * tot_pages

    threads = 10	# Number of threads for shm-fork

    # Run shm-fork once using half available hugepages, then once using all

    # This is to catch off-by-ones or races in the kernel allocated that

    # can make allocating all hugepages a problem

    if nr_pages > 1:

        do_shm_test(("shm-fork", repr(threads), repr(nr_pages // 2)), limit)

    do_shm_test(("shm-fork", repr(threads), repr(nr_pages)), limit)

    do_shm_test(("shm-getraw", repr(nr_pages), "/dev/full"), limit)

    do_test("fallocate_stress.sh")

def print_help():

    print("Usage: %s [options]" % sys.argv[0])

    print("Options:")

    print("  -v	\t Verbose output.")

    print("  -V	\t Highly verbose output.")

    print("  -f	\t Force all tests.")

    print("  -t <set> 	 Run test set, allowed are func and stress.")

    print("  -b <wordsize>  Define wordsizes to be used. ")

    print("  -p <pagesize>  Define the page sizes to be used.")

    print("  -c	\t Do a paranoid pool check.")

    print("  -l	\t Use custom ld scripts.")

    print("  -h	\t This help.")

    sys.exit(0)

def main():

    global wordsizes, pagesizes, dangerous, paranoid_pool_check, system_default_hpage_size

    global custom_ldscripts

    testsets = set()

    env_override = {"QUIET_TEST": "1", "HUGETLBFS_MOUNTS": "",

                    "HUGETLB_ELFMAP": None, "HUGETLB_MORECORE": None}

    env_defaults = {"HUGETLB_VERBOSE": "0"}

    dangerous = 0

    paranoid_pool_check = False

    custom_ldscripts = False

    try:

        opts, args = getopt.getopt(sys.argv[1:], "vVft:b:p:c:lh")

    except getopt.GetoptError as err:

        print(str(err))

        sys.exit(1)

    for opt, arg in opts:

       if opt == "-v":

           env_override["QUIET_TEST"] = None

           env_defaults["HUGETLB_VERBOSE"] = "2"

       elif opt == "-V":

           env_defaults["HUGETLB_VERBOSE"] = "99"

       elif opt == "-f":

           dangerous = 1

       elif opt == "-t":

           for t in arg.split(): testsets.add(t)

       elif opt == "-b":

           for b in arg.split(): wordsizes.add(int(b))

       elif opt == "-p":

           for p in arg.split(): pagesizes.add(int(p))

       elif opt == '-c':

           paranoid_pool_check = True

       elif opt == '-l':

           custom_ldscripts = True

       elif opt == '-h':

           print_help()

       else:

           assert False, "unhandled option"

    if len(testsets) == 0: testsets = set(["func", "stress"])

    if len(wordsizes) == 0: wordsizes = get_wordsizes()

    if len(pagesizes) == 0: pagesizes = get_pagesizes()

    if len(pagesizes) == 0:

        print("Unable to find available page sizes, are you sure hugetlbfs")

        print("is mounted and there are available huge pages?")

        return 1

    setup_env(env_override, env_defaults)

    init_results()

    (rc, system_default_hpage_size) = hpage_size()

    if rc != 0:

        print("Unable to find system default hugepage size.")

        print("Is hugepage supported included in this kernel?")

        return 1

    check_hugetlbfs_path()

    if "func" in testsets: functional_tests()

    if "stress" in testsets: stress_tests()

    results_summary()

if __name__ == "__main__":

    main()