/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Kernel Machine Description (MD)
 *
 * The Kernel maintains a global copy of the machine description for
 * the system. This is for use by all kernel subsystems and is exported
 * to user applications through the the 'mdesc' device driver. It is
 * initially copied in from the Hypervisor at boot time, but can be
 * updated dynamically on demand. The Kernel provides an interface
 * for consumers to obtain a handle to the global MD. Consumers of the
 * MD must use the specified interfaces. An update interface is provided
 * for platform services to intiate an MD update on notification by a
 * service entity.
 *
 * Locks
 * The current global MD is protected by the curr_mach_descrip_lock.
 * Each Machine description has a lock to synchornize its ref count.
 * The Obsolete MD list is protected by the obs_list_lock.
 */

#include <sys/machsystm.h>
#include <sys/vm.h>
#include <sys/cpu.h>
#include <sys/intreg.h>
#include <sys/machcpuvar.h>
#include <sys/machparam.h>
#include <vm/hat_sfmmu.h>
#include <vm/seg_kmem.h>
#include <sys/error.h>
#include <sys/hypervisor_api.h>
#include <sys/types.h>
#include <sys/sysmacros.h>
#include <sys/mdesc.h>
#include <sys/mdesc_impl.h>
#include <sys/mach_descrip.h>
#include <sys/prom_plat.h>
#include <sys/promif.h>
#include <sys/ldoms.h>

static void *mach_descrip_strt_meta_alloc(size_t size);
static void mach_descrip_strt_meta_free(void *buf, size_t size);
static void *mach_descrip_strt_buf_alloc(size_t size, size_t align);
static void mach_descrip_strt_buf_free(void *buf, size_t size);
static void *mach_descrip_buf_alloc(size_t size, size_t align);
static void *mach_descrip_meta_alloc(size_t size);
static uint64_t mach_descrip_find_md_gen(caddr_t ptr);
static void init_md_params(void);
static void init_domaining_capabilities(md_t *mdp, mde_cookie_t *listp);

/*
 * Global ptr of the current generation Machine Description
 */
static machine_descrip_t *curr_mach_descrip;

/*
 * Initialized by machine_descrip_startup_init in startup.
 * machine_descript_init will reintialize the structure with
 * the vmem allocators once the vmem is available in the boot up
 * process.
 */
static machine_descrip_memops_t *curr_mach_descrip_memops = NULL;

static machine_descrip_memops_t startup_memops = {
        mach_descrip_strt_buf_alloc,
        mach_descrip_strt_buf_free,
        mach_descrip_strt_meta_alloc,
        mach_descrip_strt_meta_free,
};

static machine_descrip_memops_t mach_descrip_memops = {
        mach_descrip_buf_alloc,
        contig_mem_free,
        mach_descrip_meta_alloc,
        kmem_free,
};

static kmutex_t curr_mach_descrip_lock;
/*
 * List of obsolete Machine Descriptions
 * Machine descriptions that have users are put on this list
 * and freed after the last user has called md_fini_handle.
 */
static machine_descrip_t *obs_machine_descrip_list;

static kmutex_t obs_list_lock;

static const char alloc_fail_msg[] =
        "MD: cannot allocate MD buffer of size %ld bytes\n";

/*
 * Global flags that indicate what domaining features are
 * available, if any. The value is set at boot time based on
 * the value of the 'domaining-enabled' property in the MD
 * and the global override flag below. Updates to this
 * variable after boot are not supported.
 */
uint_t domaining_capabilities;

/*
 * Global override for the 'domaining_capailities' flags. If this
 * flag is set in /etc/system, domaining features are disabled,
 * ignoring the value of the 'domaining-enabled' property in
 * the MD.
 */
uint_t force_domaining_disabled;

#define META_ALLOC_ALIGN        8
#define HAS_GEN(x)      (x != MDESC_INVAL_GEN)

#ifdef DEBUG
static int mach_descrip_debug = 0;

#define MDP(ARGS)       if (mach_descrip_debug) prom_printf ARGS
#define PRINT_LIST()    if (mach_descrip_debug) print_obs_list()

#ifdef  MACH_DESC_DEBUG
static void
dump_buf(uint8_t *bufp, int size)
{
        int i;
        for (i = 0; i < size; i += 16) {
                int j;
                prom_printf("0x%04x :", i);
                for (j = 0; j < 16 && (i+j) < size; j++)
                        prom_printf(" %02x", bufp[i+j]);
                prom_printf("\n");
        }
}
#endif /* MACH_DESC_DEBUG */

static void
print_obs_list(void)
{
        machine_descrip_t *lmdescp;
        mutex_enter(&obs_list_lock);

        lmdescp = obs_machine_descrip_list;
        prom_printf("MD_obs_list->");
        while (lmdescp != NULL) {
                prom_printf("g:%ld,r:%d", lmdescp->gen, lmdescp->refcnt);

                lmdescp = lmdescp->next;
                prom_printf("->");
        }
        prom_printf("NULL\n");
        mutex_exit(&obs_list_lock);
}

#else
#define MDP(ARGS)
#define PRINT_LIST()
#endif /* DEBUG */

/*
 * MD obsolete list managment functions
 */
static machine_descrip_t *
md_obs_list_look_up_by_gen(uint64_t gen)
{
        machine_descrip_t *mdescp;

        mutex_enter(&obs_list_lock);
        mdescp = obs_machine_descrip_list;

        while (mdescp != NULL) {
                if (mdescp->gen == gen) {
                        mutex_exit(&obs_list_lock);
                        return (mdescp);
                }
                mdescp = mdescp->next;
        }

        mutex_exit(&obs_list_lock);
        return (mdescp);
}

static void
md_obs_list_remove(machine_descrip_t *mdescp)
{
        machine_descrip_t *lmdescp;

        mutex_enter(&obs_list_lock);

        lmdescp = obs_machine_descrip_list;

        if (obs_machine_descrip_list == mdescp) {
                obs_machine_descrip_list = mdescp->next;
        } else {
                while (lmdescp != NULL) {
                        if (lmdescp->next == mdescp) {
                                lmdescp->next = mdescp->next;
                                mdescp->next = NULL;
                                break;
                        }
                        lmdescp = lmdescp->next;
                }
        }
        mutex_exit(&obs_list_lock);
        PRINT_LIST();
}

static void
md_obs_list_add(machine_descrip_t *mdescp)
{
        mutex_enter(&obs_list_lock);

        mdescp->next = obs_machine_descrip_list;
        obs_machine_descrip_list = mdescp;

        mutex_exit(&obs_list_lock);
        PRINT_LIST();
}

/*
 * Allocate a machine_descrip meta structure and intitialize it.
 */
static machine_descrip_t *
new_mach_descrip(void)
{
        machine_descrip_t *mdescp;

        mdescp = (machine_descrip_t *)(*curr_mach_descrip_memops->meta_allocp)
            (sizeof (machine_descrip_t));
        if (mdescp != NULL) {
                bzero(mdescp, sizeof (*mdescp));
                mdescp->memops = curr_mach_descrip_memops;
                mutex_init(&mdescp->lock, NULL, MUTEX_DRIVER, NULL);
        }

        return (mdescp);
}

/*
 * Free a machine_descrip meta structure and intitialize it.
 * Also free the MD buffer.
 */
static void
destroy_machine_descrip(machine_descrip_t *mdescp)
{
        machine_descrip_memops_t  *mdesc_memopsp;

        ASSERT((mdescp != NULL));

        mdesc_memopsp = mdescp->memops;
        if (mdescp->memops == NULL)
                panic("destroy_machine_descrip: memops NULL\n");

        (*mdesc_memopsp->buf_freep)(mdescp->va, mdescp->space);
        mutex_destroy(&mdescp->lock);
        (*mdesc_memopsp->meta_freep)(mdescp, sizeof (*mdescp));
}

/*
 * Call into the Hypervisor to retrieve the most recent copy of the
 * machine description. If references to the current MD are active
 * stow it in the obsolete MD list and update the current MD reference
 * with the new one.
 * The obsolete list contains one MD per generation. If the firmware
 * doesn't support MD generation fail the call.
 */
int
mach_descrip_update(void)
{
        uint64_t        md_size0, md_size;
        uint64_t        md_space = 0;
        uint64_t        hvret;
        caddr_t         tbuf = NULL;
        uint64_t        tbuf_pa;
        uint64_t        tgen;
        int             ret = 0;

        MDP(("MD: Requesting buffer size\n"));

        ASSERT((curr_mach_descrip != NULL));

        mutex_enter(&curr_mach_descrip_lock);

        /*
         * If the required MD size changes between our first call
         * to hv_mach_desc (to find the required buf size) and the
         * second call (to get the actual MD) and our allocated
         * memory is insufficient, loop until we have allocated
         * sufficient space.
         */
        do {
                if (tbuf != NULL)
                        (*curr_mach_descrip_memops->buf_freep)(tbuf, md_space);

                md_size0 = 0LL;
                (void) hv_mach_desc((uint64_t)0, &md_size0);
                MDP(("MD: buffer size is %ld\n", md_size0));

                /*
                 * Align allocated space to nearest page.
                 * contig_mem_alloc_align() requires a power of 2 alignment.
                 */
                md_space = P2ROUNDUP(md_size0, PAGESIZE);
                MDP(("MD: allocated space is %ld\n", md_space));

                tbuf = (caddr_t)(*curr_mach_descrip_memops->buf_allocp)
                    (md_space, PAGESIZE);
                if (tbuf == NULL) {
                        ret = -1;
                        goto done;
                }

                tbuf_pa =  va_to_pa(tbuf);
                md_size = md_space;
                hvret = hv_mach_desc(tbuf_pa, &md_size);
                MDP(("MD: HV return code = %ld\n", hvret));

                /*
                 * We get H_EINVAL if our buffer size is too small. In
                 * that case stay in the loop, reallocate the buffer
                 * and try again.
                 */
                if (hvret != H_EOK && hvret != H_EINVAL) {
                        MDP(("MD: Failed with code %ld from HV\n", hvret));
                        ret = -1;
                        goto done;
                }

        } while (md_space < md_size);

        tgen = mach_descrip_find_md_gen(tbuf);

#ifdef DEBUG
        if (!HAS_GEN(tgen)) {
                MDP(("MD: generation number not found\n"));
        } else
                MDP(("MD: generation number %ld\n", tgen));
#endif /* DEBUG */

        if (curr_mach_descrip->va != NULL) {

                /* check for the same generation number */
                if (HAS_GEN(tgen) && ((curr_mach_descrip->gen == tgen) &&
                    (curr_mach_descrip->size == md_size))) {
#ifdef DEBUG
                        /*
                         * Pedantic Check for generation number. If the
                         * generation number is the same, make sure the
                         * MDs are really identical.
                         */
                        if (bcmp(curr_mach_descrip->va, tbuf, md_size) != 0) {
                                cmn_err(CE_WARN, "machine_descrip_update: MDs "
                                    "with the same generation (%ld) are not "
                                    "identical", tgen);
                                ret = -1;
                                goto done;
                        }
#endif
                        ret = 0;
                        goto done;
                }

                /* check for generations moving backwards */
                if (HAS_GEN(tgen) && HAS_GEN(curr_mach_descrip->gen) &&
                    (curr_mach_descrip->gen > tgen)) {
                        cmn_err(CE_WARN, "machine_descrip_update: new MD"
                            " older generation (%ld) than current MD (%ld)",
                            tgen, curr_mach_descrip->gen);
                        ret = -1;
                        goto done;
                }

                if (curr_mach_descrip->refcnt == 0) {

                        MDP(("MD: freeing old md buffer gen %ld\n",
                            curr_mach_descrip->gen));

                        /* Free old space */
                        ASSERT(curr_mach_descrip->space > 0);

                        (*curr_mach_descrip_memops->buf_freep)
                            (curr_mach_descrip->va, curr_mach_descrip->space);
                } else {
                        if (!HAS_GEN(tgen)) {
                                /*
                                 * No update support if FW
                                 * doesn't have MD generation id
                                 * feature.
                                 */
                                prom_printf("WARNING: F/W does not support MD "
                                    "generation count, MD update failed\n");
                                ret = -1;
                                goto done;
                        }

                        MDP(("MD: adding to obs list %ld\n",
                            curr_mach_descrip->gen));

                        md_obs_list_add(curr_mach_descrip);

                        curr_mach_descrip = new_mach_descrip();

                        if (curr_mach_descrip == NULL) {
                                panic("Allocation for machine description"
                                    " failed\n");
                        }
                }
        }

        curr_mach_descrip->va = tbuf;
        curr_mach_descrip->gen = tgen;
        curr_mach_descrip->size = md_size;
        curr_mach_descrip->space = md_space;

#ifdef MACH_DESC_DEBUG
        dump_buf((uint8_t *)curr_mach_descrip->va, md_size);
#endif /* MACH_DESC_DEBUG */

        mutex_exit(&curr_mach_descrip_lock);
        return (ret);

done:
        if (tbuf != NULL)
                (*curr_mach_descrip_memops->buf_freep)(tbuf, md_space);
        mutex_exit(&curr_mach_descrip_lock);
        return (ret);
}

static void *
mach_descrip_buf_alloc(size_t size, size_t align)
{
        void *p;

        if ((p = contig_mem_alloc_align(size, align)) == NULL)
                cmn_err(CE_WARN, alloc_fail_msg, size);

        return (p);
}

static void *
mach_descrip_strt_meta_alloc(size_t size)
{
        return (mach_descrip_strt_buf_alloc(size, META_ALLOC_ALIGN));
}

static void
mach_descrip_strt_meta_free(void *buf, size_t size)
{
        mach_descrip_strt_buf_free(buf, size);
}

static void *
mach_descrip_strt_buf_alloc(size_t size, size_t align)
{
        void *p = prom_alloc((caddr_t)0, size, align);

        if (p == NULL)
                prom_printf(alloc_fail_msg, size);

        return (p);
}

static void
mach_descrip_strt_buf_free(void *buf, size_t size)
{
        prom_free((caddr_t)buf, size);
}

static void *
mach_descrip_meta_alloc(size_t size)
{
        return (kmem_alloc(size, KM_SLEEP));
}

/*
 * Initialize the kernel's Machine Description(MD) framework
 * early on in startup during mlsetup() so consumers
 * can get to the MD before the VM system has been initialized.
 *
 * Also get the most recent version of the MD.
 */
void
mach_descrip_startup_init(void)
{

        mutex_init(&curr_mach_descrip_lock, NULL, MUTEX_DRIVER, NULL);
        mutex_init(&obs_list_lock, NULL, MUTEX_DRIVER, NULL);

        obs_machine_descrip_list = NULL;

        curr_mach_descrip_memops = &startup_memops;

        curr_mach_descrip = new_mach_descrip();
        if (curr_mach_descrip == NULL)
                panic("Allocation for machine description failed\n");

        if (mach_descrip_update())
                panic("Machine description initialization failed\n");

}

/*
 * Counterpart to the above init function.  Free up resources
 * allocated at startup by mach_descrip_startup_setup().
 * And reset machine description framework state.
 *
 * All consumers must have fini'ed their handles at this point.
 */
void
mach_descrip_startup_fini(void)
{

        ASSERT((curr_mach_descrip != NULL));
        ASSERT((curr_mach_descrip->refcnt == 0));
        ASSERT((obs_machine_descrip_list == NULL));

        destroy_machine_descrip(curr_mach_descrip);
        curr_mach_descrip = NULL;
        curr_mach_descrip_memops = NULL;
}

/*
 * Initialize the kernel's Machine Description(MD) framework
 * after the the VM system has been initialized.
 *
 * Also get the most recent version of the MD.
 * Assumes that the machine description frame work is in a clean
 * state and the machine description intialized during startup
 * has been cleaned up and resources deallocated.
 */
void
mach_descrip_init(void)
{
        ASSERT((curr_mach_descrip == NULL &&
            curr_mach_descrip_memops == NULL));

        curr_mach_descrip_memops = &mach_descrip_memops;

        curr_mach_descrip = new_mach_descrip();
        if (curr_mach_descrip == NULL)
                panic("Allocation for machine description failed\n");

        if (mach_descrip_update())
                panic("Machine description intialization failed\n");

        /* read in global params */
        init_md_params();
}

/*
 * Client interface to get a handle to the current MD.
 * The md_fini_handle() interface should be used to
 * clean up the refernce to the MD returned by this function.
 */
md_t *
md_get_handle(void)
{
        md_t *mdp;

        mdp = NULL;

        mutex_enter(&curr_mach_descrip_lock);

        if (curr_mach_descrip != NULL) {

                mdp = md_init_intern(curr_mach_descrip->va,
                    curr_mach_descrip->memops->meta_allocp,
                    curr_mach_descrip->memops->meta_freep);

                if (mdp != NULL)
                        curr_mach_descrip->refcnt++;
        }

        mutex_exit(&curr_mach_descrip_lock);

        return (mdp);
}

/*
 * Client interface to clean up the refernce to the MD returned
 * by md_get_handle().
 */
int
md_fini_handle(md_t *ptr)
{
        machine_descrip_t *mdescp;
        md_impl_t *mdp;


        mdp = (md_impl_t *)ptr;

        if (mdp == NULL)
                return (-1);
        /*
         * Check if mdp is current MD gen
         */
        mutex_enter(&curr_mach_descrip_lock);

        if (curr_mach_descrip->gen == mdp->gen) {
                curr_mach_descrip->refcnt--;
                mutex_exit(&curr_mach_descrip_lock);
                goto fini;
        }
        mutex_exit(&curr_mach_descrip_lock);

        /*
         * MD is in the obsolete list
         */
        mdescp = md_obs_list_look_up_by_gen(mdp->gen);
        if (mdescp == NULL)
                return (-1);

        mutex_enter(&mdescp->lock);
        mdescp->refcnt--;
        if (mdescp->refcnt == 0) {
                md_obs_list_remove(mdescp);
                mutex_exit(&mdescp->lock);
                destroy_machine_descrip(mdescp);
                goto fini;
        }
        mutex_exit(&mdescp->lock);

fini:
        return (md_fini(ptr));
}

/*
 * General purpose initialization function used to extract parameters
 * from the MD during the boot process. This is called immediately after
 * the in kernel copy of the MD has been initialized so that global
 * flags are available to various subsystems as they get initialized.
 */
static void
init_md_params(void)
{
        md_t            *mdp;
        int             num_nodes;
        mde_cookie_t    *listp;
        int             listsz;

        mdp = md_get_handle();
        ASSERT(mdp);
        num_nodes = md_node_count(mdp);
        ASSERT(num_nodes >= 0);

        listsz = num_nodes * sizeof (mde_cookie_t);
        listp = (mde_cookie_t *)
            (*curr_mach_descrip_memops->meta_allocp)(listsz);

        /*
         * Import various parameters from the MD. For now,
         * the only parameter of interest is whether or not
         * domaining features are supported.
         */
        init_domaining_capabilities(mdp, listp);

        (*curr_mach_descrip_memops->meta_freep)(listp, listsz);
        (void) md_fini_handle(mdp);
}

static void
init_domaining_capabilities(md_t *mdp, mde_cookie_t *listp)
{
        mde_cookie_t    rootnode;
        int             num_nodes;
        uint64_t        val = 0;

        rootnode = md_root_node(mdp);
        ASSERT(rootnode != MDE_INVAL_ELEM_COOKIE);

        num_nodes = md_scan_dag(mdp, rootnode, md_find_name(mdp, "platform"),
            md_find_name(mdp, "fwd"), listp);

        /* should only be one platform node */
        ASSERT(num_nodes == 1);

        if (md_get_prop_val(mdp, *listp, "domaining-enabled", &val) != 0) {
                /*
                 * The property is not present. This implies
                 * that the firmware does not support domaining
                 * features.
                 */
                MDP(("'domaining-enabled' property not present\n"));

                domaining_capabilities = 0;
                return;
        }

        domaining_capabilities = DOMAINING_SUPPORTED;

        if (val == 1) {
                if (force_domaining_disabled) {
                        MDP(("domaining manually disabled\n"));
                } else {
                        domaining_capabilities |= DOMAINING_ENABLED;
                }
        }

        MDP(("domaining_capabilities= 0x%x\n", domaining_capabilities));
}

/*
 * Client interface to get a pointer to the raw MD buffer
 * Private to kernel and mdesc driver.
 */
caddr_t
md_get_md_raw(md_t *ptr)
{
        md_impl_t *mdp;

        mdp = (md_impl_t *)ptr;
        if (mdp ==  NULL)
                return (NULL);
        return (mdp->caddr);
}

/*
 * This is called before an MD structure is intialized, so
 * it walks the raw MD looking for the generation property.
 */
static uint64_t
mach_descrip_find_md_gen(caddr_t ptr)
{
        md_header_t     *hdrp;
        md_element_t    *mdep;
        md_element_t    *rootnode = NULL;
        md_element_t    *elem = NULL;
        char            *namep;
        boolean_t       done;
        int             idx;

        hdrp = (md_header_t *)ptr;
        mdep = (md_element_t *)(ptr + MD_HEADER_SIZE);
        namep = (char *)(ptr + MD_HEADER_SIZE + hdrp->node_blk_sz);

        /*
         * Very basic check for alignment to avoid
         * bus error issues.
         */
        if ((((uint64_t)ptr) & 7) != 0)
                return (MDESC_INVAL_GEN);

        if (mdtoh32(hdrp->transport_version) != MD_TRANSPORT_VERSION) {
                return (MDESC_INVAL_GEN);
        }

        /*
         * Search for the root node. Perform the walk manually
         * since the MD structure is not set up yet.
         */
        for (idx = 0, done = B_FALSE; done == B_FALSE; ) {

                md_element_t *np = &(mdep[idx]);

                switch (MDE_TAG(np)) {
                case MDET_LIST_END:
                        done = B_TRUE;
                        break;

                case MDET_NODE:
                        if (strcmp(namep + MDE_NAME(np), "root") == 0) {
                                /* found root node */
                                rootnode = np;
                                done = B_TRUE;
                                break;
                        }
                        idx = MDE_PROP_INDEX(np);
                        break;

                default:
                        /* ignore */
                        idx++;
                }
        }

        if (rootnode == NULL) {
                /* root not found */
                return (MDESC_INVAL_GEN);
        }

        /* search the rootnode for the generation property */
        for (elem = (rootnode + 1); MDE_TAG(elem) != MDET_NODE_END; elem++) {

                char *prop_name;

                /* generation field is a prop_val */
                if (MDE_TAG(elem) != MDET_PROP_VAL)
                        continue;

                prop_name = namep + MDE_NAME(elem);

                if (strcmp(prop_name, "md-generation#") == 0) {
                        return (MDE_PROP_VALUE(elem));
                }
        }

        return (MDESC_INVAL_GEN);
}

/*
 * Failed to allocate the list : Return value -1
 * md_scan_dag API failed      : Return the result from md_scan_dag API
 */
int
md_alloc_scan_dag(md_t *ptr,
        mde_cookie_t startnode,
        char *node_name,
        char *dag,
        mde_cookie_t **list)
{
        int res;
        md_impl_t *mdp = (md_impl_t *)ptr;

        *list = (mde_cookie_t *)mdp->allocp(sizeof (mde_cookie_t) *
            mdp->node_count);
        if (*list == NULL)
                return (-1);

        res = md_scan_dag(ptr, startnode,
            md_find_name(ptr, node_name),
            md_find_name(ptr, dag), *list);

        /*
         * If md_scan_dag API returned 0 or -1 then free the buffer
         * and return -1 to indicate the error from this API.
         */
        if (res < 1) {
                md_free_scan_dag(ptr, list);
                *list = NULL;
        }

        return (res);
}

void
md_free_scan_dag(md_t *ptr,
        mde_cookie_t **list)
{
        md_impl_t *mdp = (md_impl_t *)ptr;

        mdp->freep(*list, sizeof (mde_cookie_t) * mdp->node_count);
}

/*
 * Return generation number of current machine descriptor. Can be used for
 * performance purposes to avoid requesting new md handle just to see if graph
 * was updated.
 */
uint64_t
md_get_current_gen(void)
{
        uint64_t gen = MDESC_INVAL_GEN;

        mutex_enter(&curr_mach_descrip_lock);

        if (curr_mach_descrip != NULL)
                gen = (curr_mach_descrip->gen);

        mutex_exit(&curr_mach_descrip_lock);

        return (gen);
}