/* $NetBSD: t_uvm_physseg.c,v 1.11 2022/07/26 19:49:32 andvar Exp $ */

/*-
 * Copyright (c) 2015, 2016 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Santhosh N. Raju <santhosh.raju@gmail.com> and
 * by Cherry G. Mathew
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__RCSID("$NetBSD: t_uvm_physseg.c,v 1.11 2022/07/26 19:49:32 andvar Exp $");

/*
 * If this line is commented out tests related to uvm_physseg_get_pmseg()
 * wont run.
 *
 * Have a look at machine/uvm_physseg.h for more details.
 */
#define __HAVE_PMAP_PHYSSEG

/*
 * This is a dummy struct used for testing purposes
 *
 * In reality this struct would exist in the MD part of the code residing in
 * machines/vmparam.h
 */

#ifdef __HAVE_PMAP_PHYSSEG
struct pmap_physseg {
        int dummy_variable;             /* Dummy variable use for testing */
};
#endif

/* Testing API - assumes userland */
/* Provide Kernel API equivalents */
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <string.h> /* memset(3) et. al */
#include <stdio.h> /* printf(3) */
#include <stdlib.h> /* malloc(3) */
#include <stdarg.h>
#include <stddef.h>

#define PRIxPADDR       "lx"
#define PRIxPSIZE       "lx"
#define PRIuPSIZE       "lu"
#define PRIxVADDR       "lx"
#define PRIxVSIZE       "lx"
#define PRIuVSIZE       "lu"

#define UVM_HOTPLUG /* Enable hotplug with rbtree. */
#define PMAP_STEAL_MEMORY
#define DEBUG /* Enable debug functionality. */

typedef unsigned long vaddr_t;
typedef unsigned long paddr_t;
typedef unsigned long psize_t;
typedef unsigned long vsize_t;

#include <uvm/uvm_physseg.h>
#include <uvm/uvm_page.h>

#ifndef DIAGNOSTIC
#define KASSERTMSG(e, msg, ...) /* NOTHING */
#define KASSERT(e)              /* NOTHING */
#else
#define KASSERT(a)              assert(a)
#define KASSERTMSG(exp, ...)    printf(__VA_ARGS__); assert((exp))
#endif

#define VM_PHYSSEG_STRAT VM_PSTRAT_BSEARCH

#define VM_NFREELIST            4
#define VM_FREELIST_DEFAULT     0
#define VM_FREELIST_FIRST16     3
#define VM_FREELIST_FIRST1G     2
#define VM_FREELIST_FIRST4G     1

/*
 * Used in tests when Array implementation is tested
 */
#if !defined(VM_PHYSSEG_MAX)
#define VM_PHYSSEG_MAX          1
#endif

#define PAGE_SHIFT              12
#define PAGE_SIZE               (1 << PAGE_SHIFT)
#define PAGE_MASK       (PAGE_SIZE - 1)
#define atop(x)         (((paddr_t)(x)) >> PAGE_SHIFT)
#define ptoa(x)         (((paddr_t)(x)) << PAGE_SHIFT)

#define mutex_enter(l)
#define mutex_exit(l)

psize_t physmem;

struct uvmexp uvmexp;        /* decl */

/*
 * uvm structure borrowed from uvm.h
 *
 * Remember this is a dummy structure used within the ATF Tests and
 * uses only necessary fields from the original uvm struct.
 * See uvm/uvm.h for the full struct.
 */

struct uvm {
        /* vm_page related parameters */

        bool page_init_done;            /* TRUE if uvm_page_init() finished */
} uvm;

#include <sys/kmem.h>

void *
kmem_alloc(size_t size, km_flag_t flags)
{
        return malloc(size);
}

void *
kmem_zalloc(size_t size, km_flag_t flags)
{
        void *ptr;
        ptr = malloc(size);

        memset(ptr, 0, size);

        return ptr;
}

void
kmem_free(void *mem, size_t size)
{
        free(mem);
}

static void
panic(const char *fmt, ...)
{
        va_list ap;

        va_start(ap, fmt);
        vprintf(fmt, ap);
        printf("\n");
        va_end(ap);
        KASSERT(false);

        /*NOTREACHED*/
}

static void
uvm_pagefree(struct vm_page *pg)
{
        return;
}

#if defined(UVM_HOTPLUG)
static void
uvmpdpol_reinit(void)
{
        return;
}
#endif /* UVM_HOTPLUG */

/* end - Provide Kernel API equivalents */


#include "uvm/uvm_physseg.c"

#include <atf-c.h>

#define SIXTYFOUR_KILO (64 * 1024)
#define ONETWENTYEIGHT_KILO (128 * 1024)
#define TWOFIFTYSIX_KILO (256 * 1024)
#define FIVEONETWO_KILO (512 * 1024)
#define ONE_MEGABYTE (1024 * 1024)
#define TWO_MEGABYTE (2 * 1024 * 1024)

/* Sample Page Frame Numbers */
#define VALID_START_PFN_1 atop(0)
#define VALID_END_PFN_1 atop(ONE_MEGABYTE)
#define VALID_AVAIL_START_PFN_1 atop(0)
#define VALID_AVAIL_END_PFN_1 atop(ONE_MEGABYTE)

#define VALID_START_PFN_2 atop(ONE_MEGABYTE + 1)
#define VALID_END_PFN_2 atop(ONE_MEGABYTE * 2)
#define VALID_AVAIL_START_PFN_2 atop(ONE_MEGABYTE + 1)
#define VALID_AVAIL_END_PFN_2 atop(ONE_MEGABYTE * 2)

#define VALID_START_PFN_3 atop((ONE_MEGABYTE * 2) + 1)
#define VALID_END_PFN_3 atop(ONE_MEGABYTE * 3)
#define VALID_AVAIL_START_PFN_3 atop((ONE_MEGABYTE * 2) + 1)
#define VALID_AVAIL_END_PFN_3 atop(ONE_MEGABYTE * 3)

#define VALID_START_PFN_4 atop((ONE_MEGABYTE * 3) + 1)
#define VALID_END_PFN_4 atop(ONE_MEGABYTE * 4)
#define VALID_AVAIL_START_PFN_4 atop((ONE_MEGABYTE * 3) + 1)
#define VALID_AVAIL_END_PFN_4 atop(ONE_MEGABYTE * 4)

/*
 * Total number of pages (of 4K size each) should be 256 for 1MB of memory.
 */
#define PAGE_COUNT_1M      256

/*
 * A debug function to print the content of upm.
 */
        static inline void
        uvm_physseg_dump_seg(uvm_physseg_t upm)
        {
#if defined(DEBUG)
                printf("%s: seg->start == %ld\n", __func__,
                    uvm_physseg_get_start(upm));
                printf("%s: seg->end == %ld\n", __func__,
                    uvm_physseg_get_end(upm));
                printf("%s: seg->avail_start == %ld\n", __func__,
                    uvm_physseg_get_avail_start(upm));
                printf("%s: seg->avail_end == %ld\n", __func__,
                    uvm_physseg_get_avail_end(upm));

                printf("====\n\n");
#else
                return;
#endif /* DEBUG */
        }

/*
 * Private accessor that gets the value of uvm_physseg_graph.nentries
 */
static int
uvm_physseg_get_entries(void)
{
#if defined(UVM_HOTPLUG)
        return uvm_physseg_graph.nentries;
#else
        return vm_nphysmem;
#endif /* UVM_HOTPLUG */
}

#if !defined(UVM_HOTPLUG)
static void *
uvm_physseg_alloc(size_t sz)
{
        return &vm_physmem[vm_nphysseg++];
}
#endif

/*
 * This macro was added to convert uvmexp.npages from int to psize_t
 */
#define INT_TO_PSIZE_T(X) (psize_t)X

/*
 * Test Fixture SetUp().
 */
static void
setup(void)
{
        /* Prerequisites for running certain calls in uvm_physseg */
        uvmexp.pagesize = PAGE_SIZE;
        uvmexp.npages = 0;
        uvm.page_init_done = false;
        uvm_physseg_init();
}


/* <---- Tests for Internal functions ----> */
#if defined(UVM_HOTPLUG)
ATF_TC(uvm_physseg_alloc_atboot_mismatch);
ATF_TC_HEAD(uvm_physseg_alloc_atboot_mismatch, tc)
{
        atf_tc_set_md_var(tc, "descr", "boot time uvm_physseg_alloc() sanity"
            "size mismatch alloc() test.");
}

ATF_TC_BODY(uvm_physseg_alloc_atboot_mismatch, tc)
{
        uvm.page_init_done = false;

        atf_tc_expect_signal(SIGABRT, "size mismatch alloc()");

        uvm_physseg_alloc(sizeof(struct uvm_physseg) - 1);
}

ATF_TC(uvm_physseg_alloc_atboot_overrun);
ATF_TC_HEAD(uvm_physseg_alloc_atboot_overrun, tc)
{
        atf_tc_set_md_var(tc, "descr", "boot time uvm_physseg_alloc() sanity"
            "array overrun alloc() test.");
}

ATF_TC_BODY(uvm_physseg_alloc_atboot_overrun, tc)
{
        uvm.page_init_done = false;

        atf_tc_expect_signal(SIGABRT, "array overrun alloc()");

        uvm_physseg_alloc((VM_PHYSSEG_MAX + 1) * sizeof(struct uvm_physseg));

}

ATF_TC(uvm_physseg_alloc_sanity);
ATF_TC_HEAD(uvm_physseg_alloc_sanity, tc)
{
        atf_tc_set_md_var(tc, "descr", "further uvm_physseg_alloc() sanity checks");
}

ATF_TC_BODY(uvm_physseg_alloc_sanity, tc)
{

        /* At boot time */
        uvm.page_init_done = false;

        /* Correct alloc */
        ATF_REQUIRE(uvm_physseg_alloc(VM_PHYSSEG_MAX * sizeof(struct uvm_physseg)));

        /* Retry static alloc()s as dynamic - we expect them to pass */
        uvm.page_init_done = true;
        ATF_REQUIRE(uvm_physseg_alloc(sizeof(struct uvm_physseg) - 1));
        ATF_REQUIRE(uvm_physseg_alloc(2 * VM_PHYSSEG_MAX * sizeof(struct uvm_physseg)));
}

ATF_TC(uvm_physseg_free_atboot_mismatch);
ATF_TC_HEAD(uvm_physseg_free_atboot_mismatch, tc)
{
        atf_tc_set_md_var(tc, "descr", "boot time uvm_physseg_free() sanity"
            "size mismatch free() test.");
}

ATF_TC_BODY(uvm_physseg_free_atboot_mismatch, tc)
{
        uvm.page_init_done = false;

        atf_tc_expect_signal(SIGABRT, "size mismatch free()");

        uvm_physseg_free(&uvm_physseg[0], sizeof(struct uvm_physseg) - 1);
}

ATF_TC(uvm_physseg_free_sanity);
ATF_TC_HEAD(uvm_physseg_free_sanity, tc)
{
        atf_tc_set_md_var(tc, "descr", "further uvm_physseg_free() sanity checks");
}

ATF_TC_BODY(uvm_physseg_free_sanity, tc)
{

        /* At boot time */
        uvm.page_init_done = false;

        struct uvm_physseg *seg;

#if VM_PHYSSEG_MAX > 1
        /*
         * Note: free()ing the entire array is considered to be an
         * error. Thus VM_PHYSSEG_MAX - 1.
         */

        seg = uvm_physseg_alloc((VM_PHYSSEG_MAX - 1) * sizeof(*seg));
        uvm_physseg_free(seg, (VM_PHYSSEG_MAX - 1) * sizeof(struct uvm_physseg));
#endif

        /* Retry static alloc()s as dynamic - we expect them to pass */
        uvm.page_init_done = true;

        seg = uvm_physseg_alloc(sizeof(struct uvm_physseg) - 1);
        uvm_physseg_free(seg, sizeof(struct uvm_physseg) - 1);

        seg = uvm_physseg_alloc(2 * VM_PHYSSEG_MAX * sizeof(struct uvm_physseg));

        uvm_physseg_free(seg, 2 * VM_PHYSSEG_MAX * sizeof(struct uvm_physseg));
}

#if VM_PHYSSEG_MAX > 1
ATF_TC(uvm_physseg_atboot_free_leak);
ATF_TC_HEAD(uvm_physseg_atboot_free_leak, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "does free() leak at boot ?"
            "This test needs VM_PHYSSEG_MAX > 1)");
}

ATF_TC_BODY(uvm_physseg_atboot_free_leak, tc)
{

        /* At boot time */
        uvm.page_init_done = false;

        /* alloc to array size */
        struct uvm_physseg *seg;
        seg = uvm_physseg_alloc(VM_PHYSSEG_MAX * sizeof(*seg));

        uvm_physseg_free(seg, sizeof(*seg));

        atf_tc_expect_signal(SIGABRT, "array overrun on alloc() after leak");

        ATF_REQUIRE(uvm_physseg_alloc(sizeof(struct uvm_physseg)));
}
#endif /* VM_PHYSSEG_MAX */
#endif /* UVM_HOTPLUG */

/*
 * Note: This function replicates verbatim what happens in
 * uvm_page.c:uvm_page_init().
 *
 * Please track any changes that happen there.
 */
static void
uvm_page_init_fake(struct vm_page *pagearray, psize_t pagecount)
{
        uvm_physseg_t bank;
        size_t n;

        for (bank = uvm_physseg_get_first(),
                 uvm_physseg_seg_chomp_slab(bank, pagearray, pagecount);
             uvm_physseg_valid_p(bank);
             bank = uvm_physseg_get_next(bank)) {

                n = uvm_physseg_get_end(bank) - uvm_physseg_get_start(bank);
                uvm_physseg_seg_alloc_from_slab(bank, n);
                uvm_physseg_init_seg(bank, pagearray);

                /* set up page array pointers */
                pagearray += n;
                pagecount -= n;
        }

        uvm.page_init_done = true;
}

ATF_TC(uvm_physseg_plug);
ATF_TC_HEAD(uvm_physseg_plug, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test plug functionality.");
}
/* Note: We only do the second boot time plug if VM_PHYSSEG_MAX > 1 */
ATF_TC_BODY(uvm_physseg_plug, tc)
{
        int nentries = 0; /* Count of entries via plug done so far */
        uvm_physseg_t upm1;
#if VM_PHYSSEG_MAX > 2
        uvm_physseg_t upm2;
#endif

#if VM_PHYSSEG_MAX > 1
        uvm_physseg_t upm3;
#endif
        uvm_physseg_t upm4;
        psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1);
        psize_t npages2 = (VALID_END_PFN_2 - VALID_START_PFN_2);
        psize_t npages3 = (VALID_END_PFN_3 - VALID_START_PFN_3);
        psize_t npages4 = (VALID_END_PFN_4 - VALID_START_PFN_4);
        struct vm_page *pgs, *slab = malloc(sizeof(struct vm_page) * (npages1
#if VM_PHYSSEG_MAX > 2
                + npages2
#endif
                + npages3));

        /* Fake early boot */

        setup();

        /* Vanilla plug x 2 */
        ATF_REQUIRE_EQ(uvm_physseg_plug(VALID_START_PFN_1, npages1, &upm1), true);
        ATF_REQUIRE_EQ(++nentries, uvm_physseg_get_entries());
        ATF_REQUIRE_EQ(0, uvmexp.npages);

#if VM_PHYSSEG_MAX > 2
        ATF_REQUIRE_EQ(uvm_physseg_plug(VALID_START_PFN_2, npages2, &upm2), true);
        ATF_REQUIRE_EQ(++nentries, uvm_physseg_get_entries());
        ATF_REQUIRE_EQ(0, uvmexp.npages);
#endif
        /* Post boot: Fake all segments and pages accounted for. */
        uvm_page_init_fake(slab, npages1 + npages2 + npages3);

        ATF_CHECK_EQ(npages1
#if VM_PHYSSEG_MAX > 2
            + npages2
#endif
            , INT_TO_PSIZE_T(uvmexp.npages));
#if VM_PHYSSEG_MAX > 1
        /* Scavenge plug - goes into the same slab */
        ATF_REQUIRE_EQ(uvm_physseg_plug(VALID_START_PFN_3, npages3, &upm3), true);
        ATF_REQUIRE_EQ(++nentries, uvm_physseg_get_entries());
        ATF_REQUIRE_EQ(npages1
#if VM_PHYSSEG_MAX > 2
            + npages2
#endif
            + npages3, INT_TO_PSIZE_T(uvmexp.npages));

        /* Scavenge plug should fit right in the slab */
        pgs = uvm_physseg_get_pg(upm3, 0);
        ATF_REQUIRE(pgs > slab && pgs < (slab + npages1 + npages2 + npages3));
#endif
        /* Hot plug - goes into a brand new slab */
        ATF_REQUIRE_EQ(uvm_physseg_plug(VALID_START_PFN_4, npages4, &upm4), true);
        /* The hot plug slab should have nothing to do with the original slab */
        pgs = uvm_physseg_get_pg(upm4, 0);
        ATF_REQUIRE(pgs < slab || pgs >= (slab + npages1
#if VM_PHYSSEG_MAX > 2
                + npages2
#endif
                + npages3));

}
ATF_TC(uvm_physseg_unplug);
ATF_TC_HEAD(uvm_physseg_unplug, tc)
{
        atf_tc_set_md_var(tc, "descr",
            "Test unplug functionality.");
}
ATF_TC_BODY(uvm_physseg_unplug, tc)
{
        paddr_t pa = 0;

        psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1);
        psize_t npages2 = (VALID_END_PFN_2 - VALID_START_PFN_2);
        psize_t npages3 = (VALID_END_PFN_3 - VALID_START_PFN_3);

        struct vm_page *slab = malloc(sizeof(struct vm_page) * (npages1 + npages2 + npages3));

        uvm_physseg_t upm;

        /* Boot time */
        setup();

        /* We start with zero segments */
        ATF_REQUIRE_EQ(true, uvm_physseg_plug(atop(0), atop(ONE_MEGABYTE), NULL));
        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());
        /* Do we have an arbitrary offset in there ? */
        uvm_physseg_find(atop(TWOFIFTYSIX_KILO), &pa);
        ATF_REQUIRE_EQ(pa, atop(TWOFIFTYSIX_KILO));
        ATF_REQUIRE_EQ(0, uvmexp.npages); /* Boot time sanity */

#if VM_PHYSSEG_MAX == 1
        /*
         * This is the curious case at boot time, of having one
         * extent(9) static entry per segment, which means that a
         * fragmenting unplug will fail.
         */
        atf_tc_expect_signal(SIGABRT, "fragmenting unplug for single segment");

        /*
         * In order to test the fragmenting cases, please set
         * VM_PHYSSEG_MAX > 1
         */
#endif
        /* Now let's unplug from the middle */
        ATF_REQUIRE_EQ(true, uvm_physseg_unplug(atop(TWOFIFTYSIX_KILO), atop(FIVEONETWO_KILO)));
        /* verify that a gap exists at TWOFIFTYSIX_KILO */
        pa = 0; /* reset */
        uvm_physseg_find(atop(TWOFIFTYSIX_KILO), &pa);
        ATF_REQUIRE_EQ(pa, 0);

        /* Post boot: Fake all segments and pages accounted for. */
        uvm_page_init_fake(slab, npages1 + npages2 + npages3);
        /* Account for the unplug */
        ATF_CHECK_EQ(atop(FIVEONETWO_KILO), uvmexp.npages);

        /* Original entry should fragment into two */
        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        upm = uvm_physseg_find(atop(TWOFIFTYSIX_KILO + FIVEONETWO_KILO), NULL);

        ATF_REQUIRE(uvm_physseg_valid_p(upm));

        /* Now unplug the tail fragment - should swallow the complete entry */
        ATF_REQUIRE_EQ(true, uvm_physseg_unplug(atop(TWOFIFTYSIX_KILO + FIVEONETWO_KILO), atop(TWOFIFTYSIX_KILO)));

        /* The "swallow" above should have invalidated the handle */
        ATF_REQUIRE_EQ(false, uvm_physseg_valid_p(upm));

        /* Only the first one is left now */
        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        /* Unplug from the back */
        ATF_REQUIRE_EQ(true, uvm_physseg_unplug(atop(ONETWENTYEIGHT_KILO), atop(ONETWENTYEIGHT_KILO)));
        /* Shouldn't change the number of segments */
        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        /* Unplug from the front */
        ATF_REQUIRE_EQ(true, uvm_physseg_unplug(0, atop(SIXTYFOUR_KILO)));
        /* Shouldn't change the number of segments */
        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        /* Unplugging the final fragment should fail */
        atf_tc_expect_signal(SIGABRT, "Unplugging the last segment");
        ATF_REQUIRE_EQ(true, uvm_physseg_unplug(atop(SIXTYFOUR_KILO), atop(SIXTYFOUR_KILO)));
}


/* <---- end Tests for Internal functions ----> */

/* Tests for functions exported via uvm_physseg.h */
ATF_TC(uvm_physseg_init);
ATF_TC_HEAD(uvm_physseg_init, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_init() call\
            initializes the vm_physmem struct which holds the rb_tree.");
}
ATF_TC_BODY(uvm_physseg_init, tc)
{
        uvm_physseg_init();

        ATF_REQUIRE_EQ(0, uvm_physseg_get_entries());
}

ATF_TC(uvm_page_physload_preload);
ATF_TC_HEAD(uvm_page_physload_preload, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physload() \
            call works without a panic() in a preload scenario.");
}
ATF_TC_BODY(uvm_page_physload_preload, tc)
{
        uvm_physseg_t upm;

        setup();

        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Should return a valid handle */
        ATF_REQUIRE(uvm_physseg_valid_p(upm));

        /* No pages should be allocated yet */
        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* After the first call one segment should exist */
        ATF_CHECK_EQ(1, uvm_physseg_get_entries());

        /* Insert more than one segment iff VM_PHYSSEG_MAX > 1 */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        /* Should return a valid handle */
        ATF_REQUIRE(uvm_physseg_valid_p(upm));

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* After the second call two segments should exist */
        ATF_CHECK_EQ(2, uvm_physseg_get_entries());
#endif
}

ATF_TC(uvm_page_physload_postboot);
ATF_TC_HEAD(uvm_page_physload_postboot, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physload() \
             panic()s in a post boot scenario.");
}
ATF_TC_BODY(uvm_page_physload_postboot, tc)
{
        uvm_physseg_t upm;

        psize_t npages1 = (VALID_END_PFN_1 - VALID_START_PFN_1);
        psize_t npages2 = (VALID_END_PFN_2 - VALID_START_PFN_2);

        struct vm_page *slab = malloc(sizeof(struct vm_page) * (npages1 + npages2));

        setup();

        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Should return a valid handle */
        ATF_REQUIRE(uvm_physseg_valid_p(upm));

        /* No pages should be allocated yet */
        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* After the first call one segment should exist */
        ATF_CHECK_EQ(1, uvm_physseg_get_entries());

        /* Post boot: Fake all segments and pages accounted for. */
        uvm_page_init_fake(slab, npages1 + npages2);

        atf_tc_expect_signal(SIGABRT,
            "uvm_page_physload() called post boot");

        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        /* Should return a valid handle */
        ATF_REQUIRE(uvm_physseg_valid_p(upm));

        ATF_REQUIRE_EQ(npages1 + npages2, INT_TO_PSIZE_T(uvmexp.npages));

        /* After the second call two segments should exist */
        ATF_CHECK_EQ(2, uvm_physseg_get_entries());
}

ATF_TC(uvm_physseg_handle_immutable);
ATF_TC_HEAD(uvm_physseg_handle_immutable, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the uvm_physseg_t handle is \
            immutable.");
}
ATF_TC_BODY(uvm_physseg_handle_immutable, tc)
{
        uvm_physseg_t upm;

        /* We insert the segments in out of order */

        setup();

        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID_EMPTY, uvm_physseg_get_prev(upm));

        /* Insert more than one segment iff VM_PHYSSEG_MAX > 1 */
#if VM_PHYSSEG_MAX > 1
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        /* Fetch Previous, we inserted a lower value */
        upm = uvm_physseg_get_prev(upm);

#if !defined(UVM_HOTPLUG)
        /*
         * This test is going to fail for the Array Implementation but is
         * expected to pass in the RB Tree implementation.
         */
        /* Failure can be expected iff there are more than one handles */
        atf_tc_expect_fail("Mutable handle in static array impl.");
#endif
        ATF_CHECK(UVM_PHYSSEG_TYPE_INVALID_EMPTY != upm);
        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));
#endif
}

ATF_TC(uvm_physseg_seg_chomp_slab);
ATF_TC_HEAD(uvm_physseg_seg_chomp_slab, tc)
{
        atf_tc_set_md_var(tc, "descr", "The slab import code.()");

}
ATF_TC_BODY(uvm_physseg_seg_chomp_slab, tc)
{
        int err;
        size_t i;
        struct uvm_physseg *seg;
        struct vm_page *slab, *pgs;
        const size_t npages = UVM_PHYSSEG_BOOT_UNPLUG_MAX; /* Number of pages */

        setup();

        /* This is boot time */
        slab = malloc(sizeof(struct vm_page) * npages * 2);

        seg = uvm_physseg_alloc(sizeof(struct uvm_physseg));

        uvm_physseg_seg_chomp_slab(PHYSSEG_NODE_TO_HANDLE(seg), slab, npages * 2);

        /* Should be able to allocate two 128 * sizeof(*slab) */
        ATF_REQUIRE_EQ(0, extent_alloc(seg->ext, sizeof(*slab), 1, 0, EX_BOUNDZERO, (void *)&pgs));
        err = extent_free(seg->ext, (u_long) pgs, sizeof(*slab), EX_BOUNDZERO);

#if VM_PHYSSEG_MAX == 1
        /*
         * free() needs an extra region descriptor, but we only have
         * one! The classic alloc() at free() problem
         */

        ATF_REQUIRE_EQ(ENOMEM, err);
#else
        /* Try alloc/free at static time */
        for (i = 0; i < npages; i++) {
                ATF_REQUIRE_EQ(0, extent_alloc(seg->ext, sizeof(*slab), 1, 0, EX_BOUNDZERO, (void *)&pgs));
                err = extent_free(seg->ext, (u_long) pgs, sizeof(*slab), EX_BOUNDZERO);
                ATF_REQUIRE_EQ(0, err);
        }
#endif

        /* Now setup post boot */
        uvm.page_init_done = true;

        uvm_physseg_seg_chomp_slab(PHYSSEG_NODE_TO_HANDLE(seg), slab, npages * 2);

        /* Try alloc/free after uvm_page.c:uvm_page_init() as well */
        for (i = 0; i < npages; i++) {
                ATF_REQUIRE_EQ(0, extent_alloc(seg->ext, sizeof(*slab), 1, 0, EX_BOUNDZERO, (void *)&pgs));
                err = extent_free(seg->ext, (u_long) pgs, sizeof(*slab), EX_BOUNDZERO);
                ATF_REQUIRE_EQ(0, err);
        }

}

ATF_TC(uvm_physseg_alloc_from_slab);
ATF_TC_HEAD(uvm_physseg_alloc_from_slab, tc)
{
        atf_tc_set_md_var(tc, "descr", "The slab alloc code.()");

}
ATF_TC_BODY(uvm_physseg_alloc_from_slab, tc)
{
        struct uvm_physseg *seg;
        struct vm_page *slab, *pgs;
        const size_t npages = UVM_PHYSSEG_BOOT_UNPLUG_MAX; /* Number of pages */

        setup();

        /* This is boot time */
        slab = malloc(sizeof(struct vm_page) * npages * 2);

        seg = uvm_physseg_alloc(sizeof(struct uvm_physseg));

        uvm_physseg_seg_chomp_slab(PHYSSEG_NODE_TO_HANDLE(seg), slab, npages * 2);

        pgs = uvm_physseg_seg_alloc_from_slab(PHYSSEG_NODE_TO_HANDLE(seg), npages);

        ATF_REQUIRE(pgs != NULL);

        /* Now setup post boot */
        uvm.page_init_done = true;

#if VM_PHYSSEG_MAX > 1
        pgs = uvm_physseg_seg_alloc_from_slab(PHYSSEG_NODE_TO_HANDLE(seg), npages);
        ATF_REQUIRE(pgs != NULL);
#endif
        atf_tc_expect_fail("alloc beyond extent");

        pgs = uvm_physseg_seg_alloc_from_slab(PHYSSEG_NODE_TO_HANDLE(seg), npages);
        ATF_REQUIRE(pgs != NULL);
}

ATF_TC(uvm_physseg_init_seg);
ATF_TC_HEAD(uvm_physseg_init_seg, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if uvm_physseg_init_seg adds pages to"
            "uvmexp.npages");
}
ATF_TC_BODY(uvm_physseg_init_seg, tc)
{
        struct uvm_physseg *seg;
        struct vm_page *slab, *pgs;
        const size_t npages = UVM_PHYSSEG_BOOT_UNPLUG_MAX; /* Number of pages */

        setup();

        /* This is boot time */
        slab = malloc(sizeof(struct vm_page) * npages * 2);

        seg = uvm_physseg_alloc(sizeof(struct uvm_physseg));

        uvm_physseg_seg_chomp_slab(PHYSSEG_NODE_TO_HANDLE(seg), slab, npages * 2);

        pgs = uvm_physseg_seg_alloc_from_slab(PHYSSEG_NODE_TO_HANDLE(seg), npages);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        seg->start = 0;
        seg->end = npages;

        seg->avail_start = 0;
        seg->avail_end = npages;

        uvm_physseg_init_seg(PHYSSEG_NODE_TO_HANDLE(seg), pgs);

        ATF_REQUIRE_EQ(npages, INT_TO_PSIZE_T(uvmexp.npages));
}

#if 0
ATF_TC(uvm_physseg_init_seg);
ATF_TC_HEAD(uvm_physseg_init_seg, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physload() \
            call works without a panic() after Segment is inited.");
}
ATF_TC_BODY(uvm_physseg_init_seg, tc)
{
        uvm_physseg_t upm;
        psize_t npages = (VALID_END_PFN_1 - VALID_START_PFN_1);
        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(0, uvmexp.npages);

        /*
         * Boot time physplug needs explicit external init,
         * Duplicate what uvm_page.c:uvm_page_init() does.
         * Note: not everything uvm_page_init() does gets done here.
         * Read the source.
         */
        /* suck in backing slab, initialise extent. */
        uvm_physseg_seg_chomp_slab(upm, pgs, npages);

        /*
         * Actual pgs[] allocation, from extent.
         */
        uvm_physseg_alloc_from_slab(upm, npages);

        /* Now we initialize the segment */
        uvm_physseg_init_seg(upm, pgs);

        /* Done with boot simulation */
        extent_init();
        uvm.page_init_done = true;

        /* We have total memory of 1MB */
        ATF_CHECK_EQ(PAGE_COUNT_1M, uvmexp.npages);

        upm =uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);
        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        /* We added another 1MB so PAGE_COUNT_1M + PAGE_COUNT_1M */
        ATF_CHECK_EQ(PAGE_COUNT_1M + PAGE_COUNT_1M, uvmexp.npages);

}
#endif

ATF_TC(uvm_physseg_get_start);
ATF_TC_HEAD(uvm_physseg_get_start, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the start PFN is returned \
            correctly from a segment created via uvm_page_physload().");
}
ATF_TC_BODY(uvm_physseg_get_start, tc)
{
        uvm_physseg_t upm;

        /* Fake early boot */
        setup();

        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
#endif
}

ATF_TC(uvm_physseg_get_start_invalid);
ATF_TC_HEAD(uvm_physseg_get_start_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_start() is called with invalid \
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_start_invalid, tc)
{
        /* Check for pgs == NULL */
        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        /* Invalid uvm_physseg_t */
        ATF_CHECK_EQ((paddr_t) -1,
            uvm_physseg_get_start(UVM_PHYSSEG_TYPE_INVALID));
}

ATF_TC(uvm_physseg_get_end);
ATF_TC_HEAD(uvm_physseg_get_end, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the end PFN is returned \
            correctly from a segment created via uvm_page_physload().");
}
ATF_TC_BODY(uvm_physseg_get_end, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
#endif
}

ATF_TC(uvm_physseg_get_end_invalid);
ATF_TC_HEAD(uvm_physseg_get_end_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_end() is called with invalid \
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_end_invalid, tc)
{
        /* Check for pgs == NULL */
        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        /* Invalid uvm_physseg_t */
        ATF_CHECK_EQ((paddr_t) -1,
            uvm_physseg_get_end(UVM_PHYSSEG_TYPE_INVALID));
}

ATF_TC(uvm_physseg_get_avail_start);
ATF_TC_HEAD(uvm_physseg_get_avail_start, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the avail_start PFN is \
            returned correctly from a segment created via uvm_page_physload().");
}
ATF_TC_BODY(uvm_physseg_get_avail_start, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_1, uvm_physseg_get_avail_start(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2, uvm_physseg_get_avail_start(upm));
#endif
}

ATF_TC(uvm_physseg_get_avail_start_invalid);
ATF_TC_HEAD(uvm_physseg_get_avail_start_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_avail_start() is called with invalid\
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_avail_start_invalid, tc)
{
        /* Check for pgs == NULL */
        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        /* Invalid uvm_physseg_t */
        ATF_CHECK_EQ((paddr_t) -1,
            uvm_physseg_get_avail_start(UVM_PHYSSEG_TYPE_INVALID));
}

ATF_TC(uvm_physseg_get_avail_end);
ATF_TC_HEAD(uvm_physseg_get_avail_end, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the avail_end PFN is \
            returned correctly from a segment created via uvm_page_physload().");
}
ATF_TC_BODY(uvm_physseg_get_avail_end, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_1, uvm_physseg_get_avail_end(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));
#endif
}

ATF_TC(uvm_physseg_get_avail_end_invalid);
ATF_TC_HEAD(uvm_physseg_get_avail_end_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_avail_end() is called with invalid\
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_avail_end_invalid, tc)
{
        /* Check for pgs == NULL */
        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        /* Invalid uvm_physseg_t */
        ATF_CHECK_EQ((paddr_t) -1,
            uvm_physseg_get_avail_end(UVM_PHYSSEG_TYPE_INVALID));
}

ATF_TC(uvm_physseg_get_next);
ATF_TC_HEAD(uvm_physseg_get_next, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer values for next \
            segment using the uvm_physseg_get_next() call.");
}
ATF_TC_BODY(uvm_physseg_get_next, tc)
{
        uvm_physseg_t upm;
#if VM_PHYSSEG_MAX > 1
        uvm_physseg_t upm_next;
#endif

        /* We insert the segments in ascending order */

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID_OVERFLOW,
            uvm_physseg_get_next(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm_next = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        upm = uvm_physseg_get_next(upm); /* Fetch Next */

        ATF_CHECK_EQ(upm_next, upm);
        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        upm_next = uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(3, uvm_physseg_get_entries());

        upm = uvm_physseg_get_next(upm); /* Fetch Next */

        ATF_CHECK_EQ(upm_next, upm);
        ATF_CHECK_EQ(VALID_START_PFN_3, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_3, uvm_physseg_get_end(upm));
#endif
}

ATF_TC(uvm_physseg_get_next_invalid);
ATF_TC_HEAD(uvm_physseg_get_next_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_next() is called with invalid \
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_next_invalid, tc)
{
        uvm_physseg_t upm = UVM_PHYSSEG_TYPE_INVALID;

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID, uvm_physseg_get_next(upm));
}

ATF_TC(uvm_physseg_get_prev);
ATF_TC_HEAD(uvm_physseg_get_prev, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer values for previous \
            segment using the uvm_physseg_get_prev() call.");
}
ATF_TC_BODY(uvm_physseg_get_prev, tc)
{
#if VM_PHYSSEG_MAX > 1
        uvm_physseg_t upm;
#endif
        uvm_physseg_t upm_prev;


        setup();
        upm_prev = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID_EMPTY,
            uvm_physseg_get_prev(upm_prev));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        /* Fetch Previous, we inserted a lower value */
        upm = uvm_physseg_get_prev(upm);

        ATF_CHECK_EQ(upm_prev, upm);
        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(3, uvm_physseg_get_entries());

        /*
         * This will return a UVM_PHYSSEG_TYPE_INVALID_EMPTY we are at the
         * lowest
         */
        upm = uvm_physseg_get_prev(upm);

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID_EMPTY, upm);
#endif
}

ATF_TC(uvm_physseg_get_prev_invalid);
ATF_TC_HEAD(uvm_physseg_get_prev_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the invalid / error conditions \
            correctly when uvm_physseg_get_prev() is called with invalid \
            parameter values.");
}
ATF_TC_BODY(uvm_physseg_get_prev_invalid, tc)
{
        uvm_physseg_t upm = UVM_PHYSSEG_TYPE_INVALID;

        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID, uvm_physseg_get_prev(upm));
}

ATF_TC(uvm_physseg_get_first);
ATF_TC_HEAD(uvm_physseg_get_first, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer values for first \
            segment (lowest node) using the uvm_physseg_get_first() call.");
}
ATF_TC_BODY(uvm_physseg_get_first, tc)
{
        uvm_physseg_t upm = UVM_PHYSSEG_TYPE_INVALID_EMPTY;
        uvm_physseg_t upm_first;

        /* Fake early boot */
        setup();

        /* No nodes exist */
        ATF_CHECK_EQ(upm, uvm_physseg_get_first());

        upm_first = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        /* Pointer to first should be the least valued node */
        upm = uvm_physseg_get_first();
        ATF_CHECK_EQ(upm_first, upm);
        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        /* Insert a node of lesser value */
        upm_first = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_CHECK_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        /* Pointer to first should be the least valued node */
        upm = uvm_physseg_get_first();
        ATF_CHECK_EQ(upm_first, upm);
        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_1, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_1, uvm_physseg_get_avail_end(upm));
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        /* Insert a node of higher value */
        upm_first =uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_DEFAULT);

        ATF_CHECK_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(3, uvm_physseg_get_entries());

        /* Pointer to first should be the least valued node */
        upm = uvm_physseg_get_first();
        ATF_CHECK(upm_first != upm);
        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_1, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_1, uvm_physseg_get_avail_end(upm));
#endif
}

ATF_TC(uvm_physseg_get_last);
ATF_TC_HEAD(uvm_physseg_get_last, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer values for last \
            segment using the uvm_physseg_get_last() call.");
}
ATF_TC_BODY(uvm_physseg_get_last, tc)
{
        uvm_physseg_t upm = UVM_PHYSSEG_TYPE_INVALID_EMPTY;
        uvm_physseg_t upm_last;

        setup();

        /* No nodes exist */
        ATF_CHECK_EQ(upm, uvm_physseg_get_last());

        upm_last = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        /* Pointer to last should be the most valued node */
        upm = uvm_physseg_get_last();
        ATF_CHECK_EQ(upm_last, upm);
        ATF_CHECK_EQ(VALID_START_PFN_1, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_1, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_1, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_1, uvm_physseg_get_avail_end(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        /* Insert node of greater value */
        upm_last = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        /* Pointer to last should be the most valued node */
        upm = uvm_physseg_get_last();
        ATF_CHECK_EQ(upm_last, upm);
        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        /* Insert node of greater value */
        upm_last = uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(3, uvm_physseg_get_entries());

        /* Pointer to last should be the most valued node */
        upm = uvm_physseg_get_last();
        ATF_CHECK_EQ(upm_last, upm);
        ATF_CHECK_EQ(VALID_START_PFN_3, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_3, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_3, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_3, uvm_physseg_get_avail_end(upm));
#endif
}

ATF_TC(uvm_physseg_valid);
ATF_TC_HEAD(uvm_physseg_valid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer value for current \
            segment is valid using the uvm_physseg_valid_p() call.");
}
ATF_TC_BODY(uvm_physseg_valid, tc)
{
        psize_t npages = (VALID_END_PFN_1 - VALID_START_PFN_1);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        uvm_physseg_init_seg(upm, pgs);

        ATF_REQUIRE_EQ(PAGE_COUNT_1M, uvmexp.npages);

        ATF_CHECK_EQ(true, uvm_physseg_valid_p(upm));
}

ATF_TC(uvm_physseg_valid_invalid);
ATF_TC_HEAD(uvm_physseg_valid_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests the pointer value for current \
            segment is invalid using the uvm_physseg_valid_p() call.");
}
ATF_TC_BODY(uvm_physseg_valid_invalid, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        /* Invalid uvm_physseg_t */
        ATF_CHECK_EQ(false, uvm_physseg_valid_p(UVM_PHYSSEG_TYPE_INVALID));

        /*
         * Without any pages initialized for segment, it is considered
         * invalid
         */
        ATF_CHECK_EQ(false, uvm_physseg_valid_p(upm));
}

ATF_TC(uvm_physseg_get_highest);
ATF_TC_HEAD(uvm_physseg_get_highest, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned PFN matches  \
            the highest PFN in use by the system.");
}
ATF_TC_BODY(uvm_physseg_get_highest, tc)
{
        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Only one segment so highest is the current */
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_1 - 1, uvm_physseg_get_highest_frame());

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_DEFAULT);

        /* PFN_3 > PFN_1 */
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_3 - 1, uvm_physseg_get_highest_frame());
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        /* PFN_3 > PFN_2 */
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_3 - 1, uvm_physseg_get_highest_frame());
#endif
}

ATF_TC(uvm_physseg_get_free_list);
ATF_TC_HEAD(uvm_physseg_get_free_list, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned Free List type \
            of a segment matches the one returned from \
            uvm_physseg_get_free_list() call.");
}
ATF_TC_BODY(uvm_physseg_get_free_list, tc)
{
        uvm_physseg_t upm;

        /* Fake early boot */
        setup();

        /* Insertions are made in ascending order */
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_CHECK_EQ(VM_FREELIST_DEFAULT, uvm_physseg_get_free_list(upm));

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_FIRST16);

        ATF_CHECK_EQ(VM_FREELIST_FIRST16, uvm_physseg_get_free_list(upm));
#endif

        /* This test will be triggered only if there are 3 or more segments. */
#if VM_PHYSSEG_MAX > 2
        upm = uvm_page_physload(VALID_START_PFN_3, VALID_END_PFN_3,
            VALID_AVAIL_START_PFN_3, VALID_AVAIL_END_PFN_3, VM_FREELIST_FIRST1G);

        ATF_CHECK_EQ(VM_FREELIST_FIRST1G, uvm_physseg_get_free_list(upm));
#endif
}

ATF_TC(uvm_physseg_get_start_hint);
ATF_TC_HEAD(uvm_physseg_get_start_hint, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned start_hint value \
            of a segment matches the one returned from \
            uvm_physseg_get_start_hint() call.");
}
ATF_TC_BODY(uvm_physseg_get_start_hint, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Will be Zero since no specific value is set during init */
        ATF_CHECK_EQ(0, uvm_physseg_get_start_hint(upm));
}

ATF_TC(uvm_physseg_set_start_hint);
ATF_TC_HEAD(uvm_physseg_set_start_hint, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned start_hint value \
            of a segment matches the one set by the \
            uvm_physseg_set_start_hint() call.");
}
ATF_TC_BODY(uvm_physseg_set_start_hint, tc)
{
        psize_t npages = (VALID_END_PFN_1 - VALID_START_PFN_1);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        uvm_physseg_init_seg(upm, pgs);

        ATF_CHECK_EQ(true, uvm_physseg_set_start_hint(upm, atop(128)));

        /* Will be atop(128) since no specific value is set above */
        ATF_CHECK_EQ(atop(128), uvm_physseg_get_start_hint(upm));
}

ATF_TC(uvm_physseg_set_start_hint_invalid);
ATF_TC_HEAD(uvm_physseg_set_start_hint_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned value is false \
            when an invalid segment matches the one trying to set by the \
            uvm_physseg_set_start_hint() call.");
}
ATF_TC_BODY(uvm_physseg_set_start_hint_invalid, tc)
{
        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        /* Force other check conditions */
        uvm.page_init_done = true;

        ATF_REQUIRE_EQ(true, uvm.page_init_done);

        ATF_CHECK_EQ(false, uvm_physseg_set_start_hint(upm, atop(128)));

        /*
         * Will be Zero since no specific value is set after the init
         * due to failure
         */
        atf_tc_expect_signal(SIGABRT, "invalid uvm_physseg_t handle");

        ATF_CHECK_EQ(0, uvm_physseg_get_start_hint(upm));
}

ATF_TC(uvm_physseg_get_pg);
ATF_TC_HEAD(uvm_physseg_get_pg, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned vm_page struct \
            is correct when fetched by uvm_physseg_get_pg() call.");
}
ATF_TC_BODY(uvm_physseg_get_pg, tc)
{
        psize_t npages = (VALID_END_PFN_1 - VALID_START_PFN_1);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        struct vm_page *extracted_pg = NULL;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* Now we initialize the segment */
        uvm_physseg_init_seg(upm, pgs);

        ATF_REQUIRE_EQ(PAGE_COUNT_1M, uvmexp.npages);

        ATF_REQUIRE_EQ(NULL, extracted_pg);

        /* Try fetching the 5th Page in the Segment */
        extracted_pg = uvm_physseg_get_pg(upm, 5);

        /* Values of phys_addr is n * PAGE_SIZE where n is the page number */
        ATF_CHECK_EQ(5 * PAGE_SIZE, extracted_pg->phys_addr);

        /* Try fetching the 113th Page in the Segment */
        extracted_pg = uvm_physseg_get_pg(upm, 113);

        ATF_CHECK_EQ(113 * PAGE_SIZE, extracted_pg->phys_addr);
}

#ifdef __HAVE_PMAP_PHYSSEG
ATF_TC(uvm_physseg_get_pmseg);
ATF_TC_HEAD(uvm_physseg_get_pmseg, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned pmap_physseg \
            struct is correct when fetched by uvm_physseg_get_pmseg() call.");
}
ATF_TC_BODY(uvm_physseg_get_pmseg, tc)
{
        psize_t npages = (VALID_END_PFN_1 - VALID_START_PFN_1);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        struct pmap_physseg pmseg = { true };

        struct pmap_physseg *extracted_pmseg = NULL;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* Now we initialize the segment */
        uvm_physseg_init_seg(upm, pgs);

        ATF_REQUIRE_EQ(PAGE_COUNT_1M, uvmexp.npages);

        ATF_REQUIRE_EQ(NULL, extracted_pmseg);

        ATF_REQUIRE_EQ(true, pmseg.dummy_variable);

        /* Extract the current pmseg */
        extracted_pmseg = uvm_physseg_get_pmseg(upm);

        /*
         * We can only check if it is not NULL
         * We do not know the value it contains
         */
        ATF_CHECK(NULL != extracted_pmseg);

        extracted_pmseg->dummy_variable = pmseg.dummy_variable;

        /* Invert value to ensure test integrity */
        pmseg.dummy_variable = false;

        ATF_REQUIRE_EQ(false, pmseg.dummy_variable);

        extracted_pmseg = uvm_physseg_get_pmseg(upm);

        ATF_CHECK(NULL != extracted_pmseg);

        ATF_CHECK_EQ(true, extracted_pmseg->dummy_variable);
}
#endif

ATF_TC(vm_physseg_find);
ATF_TC_HEAD(vm_physseg_find, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned segment number \
            is correct when an PFN is passed into uvm_physseg_find() call. \
            In addition to this the offset of the PFN from the start of \
            segment is also set if the parameter is passed in as not NULL.");
}
ATF_TC_BODY(vm_physseg_find, tc)
{
        psize_t offset = (psize_t) -1;

        uvm_physseg_t upm_first, result;
#if VM_PHYSSEG_MAX > 1
        uvm_physseg_t upm_second;
#endif

        setup();

        upm_first = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        upm_second = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);
#endif

        /* Under ONE_MEGABYTE is segment upm_first */
        result = uvm_physseg_find(atop(ONE_MEGABYTE - 1024), NULL);
        ATF_CHECK_EQ(upm_first, result);
        ATF_CHECK_EQ(uvm_physseg_get_start(upm_first),
            uvm_physseg_get_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_end(upm_first),
            uvm_physseg_get_end(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_start(upm_first),
            uvm_physseg_get_avail_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_end(upm_first),
            uvm_physseg_get_avail_end(result));

        ATF_REQUIRE_EQ((psize_t) -1, offset);

        /* This test will be triggered only if there are 2 or more segments. */
#if VM_PHYSSEG_MAX > 1
        /* Over ONE_MEGABYTE is segment upm_second */
        result = uvm_physseg_find(atop(ONE_MEGABYTE + 8192), &offset);
        ATF_CHECK_EQ(upm_second, result);
        ATF_CHECK_EQ(uvm_physseg_get_start(upm_second),
            uvm_physseg_get_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_end(upm_second),
            uvm_physseg_get_end(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_start(upm_second),
            uvm_physseg_get_avail_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_end(upm_second),
            uvm_physseg_get_avail_end(result));

        /* Offset is calculated based on PAGE_SIZE */
        /* atop(ONE_MEGABYTE + (2 * PAGE_SIZE)) - VALID_START_PFN1  = 2 */
        ATF_CHECK_EQ(2, offset);
#else
        /* Under ONE_MEGABYTE is segment upm_first */
        result = uvm_physseg_find(atop(ONE_MEGABYTE - 12288), &offset);
        ATF_CHECK_EQ(upm_first, result);
        ATF_CHECK_EQ(uvm_physseg_get_start(upm_first),
            uvm_physseg_get_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_end(upm_first),
            uvm_physseg_get_end(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_start(upm_first),
            uvm_physseg_get_avail_start(result));
        ATF_CHECK_EQ(uvm_physseg_get_avail_end(upm_first),
            uvm_physseg_get_avail_end(result));

        /* Offset is calculated based on PAGE_SIZE */
        /* atop(ONE_MEGABYTE - (3 * PAGE_SIZE)) - VALID_START_PFN1  = 253 */
        ATF_CHECK_EQ(253, offset);
#endif
}

ATF_TC(vm_physseg_find_invalid);
ATF_TC_HEAD(vm_physseg_find_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the returned segment number \
            is (paddr_t) -1  when a non-existent PFN is passed into \
            uvm_physseg_find() call.");
}
ATF_TC_BODY(vm_physseg_find_invalid, tc)
{
        psize_t offset = (psize_t) -1;

        setup();
        uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* No segments over 3 MB exists at the moment */
        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID,
            uvm_physseg_find(atop(ONE_MEGABYTE * 3), NULL));

        ATF_REQUIRE_EQ((psize_t) -1, offset);

        /* No segments over 3 MB exists at the moment */
        ATF_CHECK_EQ(UVM_PHYSSEG_TYPE_INVALID,
            uvm_physseg_find(atop(ONE_MEGABYTE * 3), &offset));

        ATF_CHECK_EQ((psize_t) -1, offset);
}

ATF_TC(uvm_page_physunload_start);
ATF_TC_HEAD(uvm_page_physunload_start, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physunload()\
            call works without a panic(). Unloads from Start of the segment.");
}
ATF_TC_BODY(uvm_page_physunload_start, tc)
{
        /*
         * Would uvmexp.npages reduce everytime an uvm_page_physunload is called?
         */
        psize_t npages = (VALID_END_PFN_2 - VALID_START_PFN_2);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        uvm_physseg_init_seg(upm, pgs);

        ATF_CHECK_EQ(true, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        /*
         * When called for first time, uvm_page_physload() removes the first PFN
         *
         * New avail start will be VALID_AVAIL_START_PFN_2 + 1
         */
        ATF_CHECK_EQ(VALID_START_PFN_2, atop(p));

        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2 + 1,
            uvm_physseg_get_avail_start(upm));

        ATF_CHECK_EQ(VALID_START_PFN_2 + 1, uvm_physseg_get_start(upm));

        /* Rest of the stuff should remain the same */
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));
}

ATF_TC(uvm_page_physunload_end);
ATF_TC_HEAD(uvm_page_physunload_end, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physunload()\
            call works without a panic(). Unloads from End of the segment.");
}
ATF_TC_BODY(uvm_page_physunload_end, tc)
{
        /*
         * Would uvmexp.npages reduce everytime an uvm_page_physunload is called?
         */
        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        /* Note: start != avail_start to remove from end. */
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2 + 1, VALID_AVAIL_END_PFN_2,
            VM_FREELIST_DEFAULT);

        p = 0;

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE(
                uvm_physseg_get_avail_start(upm) != uvm_physseg_get_start(upm));

        ATF_CHECK_EQ(true, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        /*
         * Remember if X is the upper limit the actual valid pointer is X - 1
         *
         * For example if 256 is the upper limit for 1MB memory, last valid
         * pointer is 256 - 1 = 255
         */

        ATF_CHECK_EQ(VALID_END_PFN_2 - 1, atop(p));

        /*
         * When called for second time, uvm_page_physload() removes the last PFN
         *
         * New avail end will be VALID_AVAIL_END_PFN_2 - 1
         * New end will be VALID_AVAIL_PFN_2 - 1
         */

        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2 - 1, uvm_physseg_get_avail_end(upm));

        ATF_CHECK_EQ(VALID_END_PFN_2 - 1, uvm_physseg_get_end(upm));

        /* Rest of the stuff should remain the same */
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2 + 1,
            uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
}

ATF_TC(uvm_page_physunload_none);
ATF_TC_HEAD(uvm_page_physunload_none, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic uvm_page_physunload()\
            call works without a panic(). Does not unload from start or end \
            because of non-aligned start / avail_start and end / avail_end \
            respectively.");
}
ATF_TC_BODY(uvm_page_physunload_none, tc)
{
        psize_t npages = (VALID_END_PFN_2 - VALID_START_PFN_2);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        /*
         * Note: start != avail_start and end != avail_end.
         *
         * This prevents any unload from occurring.
         */
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2 + 1, VALID_AVAIL_END_PFN_2 - 1,
            VM_FREELIST_DEFAULT);

        p = 0;

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_REQUIRE(
                uvm_physseg_get_avail_start(upm) != uvm_physseg_get_start(upm));

        uvm_physseg_init_seg(upm, pgs);

        ATF_CHECK_EQ(false, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        /* uvm_page_physload() will no longer unload memory */
        ATF_CHECK_EQ(0, p);

        /* Rest of the stuff should remain the same */
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2 + 1,
            uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2 - 1,
            uvm_physseg_get_avail_end(upm));
        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
}

ATF_TC(uvm_page_physunload_delete_start);
ATF_TC_HEAD(uvm_page_physunload_delete_start, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the  uvm_page_physunload() \
            works when the segment gets small enough to be deleted scenario. \
            NOTE: This one works deletes from start.");
}
ATF_TC_BODY(uvm_page_physunload_delete_start, tc)
{
        /*
         * Would uvmexp.npages reduce everytime an uvm_page_physunload is called?
         */
        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();

        /*
         * Setup the Nuke from Starting point
         */

        upm = uvm_page_physload(VALID_END_PFN_1 - 1, VALID_END_PFN_1,
            VALID_AVAIL_END_PFN_1 - 1, VALID_AVAIL_END_PFN_1,
            VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* Insert more than one segment iff VM_PHYSSEG_MAX > 1 */
#if VM_PHYSSEG_MAX > 1
        uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());
#endif

#if VM_PHYSSEG_MAX == 1
        atf_tc_expect_signal(SIGABRT,
            "cannot uvm_page_physunload() the last segment");
#endif

        ATF_CHECK_EQ(true, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        ATF_CHECK_EQ(VALID_END_PFN_1 - 1, atop(p));

        ATF_CHECK_EQ(1, uvm_physseg_get_entries());

        /* The only node now is the one we inserted second. */
        upm = uvm_physseg_get_first();

        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));
}

ATF_TC(uvm_page_physunload_delete_end);
ATF_TC_HEAD(uvm_page_physunload_delete_end, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the  uvm_page_physunload() \
            works when the segment gets small enough to be deleted scenario. \
            NOTE: This one works deletes from end.");
}
ATF_TC_BODY(uvm_page_physunload_delete_end, tc)
{
        /*
         * Would uvmexp.npages reduce everytime an uvm_page_physunload is called?
         */

        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();

        /*
         * Setup the Nuke from Ending point
         */

        upm = uvm_page_physload(VALID_START_PFN_1, VALID_START_PFN_1 + 2,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_START_PFN_1 + 2,
            VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* Insert more than one segment iff VM_PHYSSEG_MAX > 1 */
#if VM_PHYSSEG_MAX > 1
        uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());
#endif

#if VM_PHYSSEG_MAX == 1
        atf_tc_expect_signal(SIGABRT,
            "cannot uvm_page_physunload() the last segment");
#endif

        ATF_CHECK_EQ(true, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        ATF_CHECK_EQ(VALID_START_PFN_1, atop(p));

        p = 0;

        ATF_CHECK_EQ(true, uvm_page_physunload(upm, VM_FREELIST_DEFAULT, &p));

        ATF_CHECK_EQ(VALID_START_PFN_1 + 1, atop(p));

        ATF_CHECK_EQ(1, uvm_physseg_get_entries());

        /* The only node now is the one we inserted second. */
        upm = uvm_physseg_get_first();

        ATF_CHECK_EQ(VALID_START_PFN_2, uvm_physseg_get_start(upm));
        ATF_CHECK_EQ(VALID_END_PFN_2, uvm_physseg_get_end(upm));
        ATF_CHECK_EQ(VALID_AVAIL_START_PFN_2, uvm_physseg_get_avail_start(upm));
        ATF_CHECK_EQ(VALID_AVAIL_END_PFN_2, uvm_physseg_get_avail_end(upm));
}

ATF_TC(uvm_page_physunload_invalid);
ATF_TC_HEAD(uvm_page_physunload_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the  uvm_page_physunload() \
            fails when then Free list does not match.");
}
ATF_TC_BODY(uvm_page_physunload_invalid, tc)
{
        psize_t npages = (VALID_END_PFN_2 - VALID_START_PFN_2);

        struct vm_page *pgs = malloc(sizeof(struct vm_page) * npages);

        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        uvm_physseg_init_seg(upm, pgs);

        ATF_CHECK_EQ(false, uvm_page_physunload(upm, VM_FREELIST_FIRST4G, &p));
}

ATF_TC(uvm_page_physunload_force);
ATF_TC_HEAD(uvm_page_physunload_force, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the basic \
            uvm_page_physunload_force() including delete works without.");
}
ATF_TC_BODY(uvm_page_physunload_force, tc)
{
        /*
         * Would uvmexp.npages reduce everytime an uvm_page_physunload is called?
         */
        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_1, VALID_END_PFN_1,
            VALID_AVAIL_START_PFN_1, VALID_AVAIL_END_PFN_1, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        /* Insert more than one segment iff VM_PHYSSEG_MAX > 1 */
#if VM_PHYSSEG_MAX > 1
        /*
         * We have couple of physloads done this is because of the fact that if
         * we physunload all the PFs from a given range and we have only one
         * segment in total a panic() is called
         */
        uvm_page_physload(VALID_START_PFN_2, VALID_END_PFN_2,
            VALID_AVAIL_START_PFN_2, VALID_AVAIL_END_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(2, uvm_physseg_get_entries());
#endif

#if VM_PHYSSEG_MAX == 1
        atf_tc_expect_signal(SIGABRT,
            "cannot uvm_page_physunload() the last segment");
#endif

        ATF_REQUIRE_EQ(VALID_AVAIL_START_PFN_1,
            uvm_physseg_get_avail_start(upm));

        for(paddr_t i = VALID_AVAIL_START_PFN_1;
            i < VALID_AVAIL_END_PFN_1; i++) {
                ATF_CHECK_EQ(true,
                    uvm_page_physunload_force(upm, VM_FREELIST_DEFAULT, &p));
                ATF_CHECK_EQ(i, atop(p));

                if(i + 1 < VALID_AVAIL_END_PFN_1)
                        ATF_CHECK_EQ(i + 1, uvm_physseg_get_avail_start(upm));
        }

        /*
         * Now we try to retrieve the segment, which has been removed
         * from the system through force unloading all the pages inside it.
         */
        upm = uvm_physseg_find(VALID_AVAIL_END_PFN_1 - 1, NULL);

        /* It should no longer exist */
#if defined(UVM_HOTPLUG)
        ATF_CHECK_EQ(NULL, upm);
#else
        ATF_CHECK_EQ(-1, upm);
#endif

        ATF_CHECK_EQ(1, uvm_physseg_get_entries());
}

ATF_TC(uvm_page_physunload_force_invalid);
ATF_TC_HEAD(uvm_page_physunload_force_invalid, tc)
{
        atf_tc_set_md_var(tc, "descr", "Tests if the invalid conditions for \
            uvm_page_physunload_force_invalid().");
}
ATF_TC_BODY(uvm_page_physunload_force_invalid, tc)
{
        paddr_t p = 0;

        uvm_physseg_t upm;

        setup();
        upm = uvm_page_physload(VALID_START_PFN_2, VALID_START_PFN_2+ 1,
            VALID_START_PFN_2, VALID_START_PFN_2, VM_FREELIST_DEFAULT);

        ATF_REQUIRE_EQ(1, uvm_physseg_get_entries());

        ATF_REQUIRE_EQ(0, uvmexp.npages);

        ATF_CHECK_EQ(false,
            uvm_page_physunload_force(upm, VM_FREELIST_DEFAULT, &p));

        ATF_CHECK_EQ(0, p);
}

ATF_TP_ADD_TCS(tp)
{
#if defined(UVM_HOTPLUG)
        /* Internal */
        ATF_TP_ADD_TC(tp, uvm_physseg_alloc_atboot_mismatch);
        ATF_TP_ADD_TC(tp, uvm_physseg_alloc_atboot_overrun);
        ATF_TP_ADD_TC(tp, uvm_physseg_alloc_sanity);
        ATF_TP_ADD_TC(tp, uvm_physseg_free_atboot_mismatch);
        ATF_TP_ADD_TC(tp, uvm_physseg_free_sanity);
#if VM_PHYSSEG_MAX > 1
        ATF_TP_ADD_TC(tp, uvm_physseg_atboot_free_leak);
#endif
#endif /* UVM_HOTPLUG */

        ATF_TP_ADD_TC(tp, uvm_physseg_plug);
        ATF_TP_ADD_TC(tp, uvm_physseg_unplug);

        /* Exported */
        ATF_TP_ADD_TC(tp, uvm_physseg_init);
        ATF_TP_ADD_TC(tp, uvm_page_physload_preload);
        ATF_TP_ADD_TC(tp, uvm_page_physload_postboot);
        ATF_TP_ADD_TC(tp, uvm_physseg_handle_immutable);
        ATF_TP_ADD_TC(tp, uvm_physseg_seg_chomp_slab);
        ATF_TP_ADD_TC(tp, uvm_physseg_alloc_from_slab);
        ATF_TP_ADD_TC(tp, uvm_physseg_init_seg);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_start);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_start_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_end);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_end_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_avail_start);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_avail_start_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_avail_end);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_avail_end_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_next);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_next_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_prev);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_prev_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_first);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_last);
        ATF_TP_ADD_TC(tp, uvm_physseg_valid);
        ATF_TP_ADD_TC(tp, uvm_physseg_valid_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_highest);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_free_list);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_start_hint);
        ATF_TP_ADD_TC(tp, uvm_physseg_set_start_hint);
        ATF_TP_ADD_TC(tp, uvm_physseg_set_start_hint_invalid);
        ATF_TP_ADD_TC(tp, uvm_physseg_get_pg);

#ifdef __HAVE_PMAP_PHYSSEG
        ATF_TP_ADD_TC(tp, uvm_physseg_get_pmseg);
#endif
        ATF_TP_ADD_TC(tp, vm_physseg_find);
        ATF_TP_ADD_TC(tp, vm_physseg_find_invalid);

        ATF_TP_ADD_TC(tp, uvm_page_physunload_start);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_end);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_none);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_delete_start);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_delete_end);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_invalid);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_force);
        ATF_TP_ADD_TC(tp, uvm_page_physunload_force_invalid);

        return atf_no_error();
}