dmake: do not set MAKEFLAGS=k

[unleashed/tickless.git] / usr / src / lib / liblgrp / common / lgrp.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"


/*
 * lgroup interface
 */
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <sys/bitmap.h>
#include <sys/pset.h>
#include <sys/types.h>

#include <sys/lgrp_user.h>


/*
 * Fast trap for getting home lgroup of current thread
 */
extern lgrp_id_t        _lgrp_home_fast(void);

/*
 * lgroup system call
 */
extern int              _lgrpsys(int subcode, long arg, void *ap);

static int lgrp_cpus_hier(lgrp_snapshot_header_t *snap, lgrp_id_t lgrp,
    processorid_t **cpuids, uint_t *count);


/*
 * Get generation ID of lgroup hierarchy given view
 * which changes whenever the hierarchy changes (eg. DR or pset contents
 * change for caller's view)
 */
static lgrp_gen_t
lgrp_generation(lgrp_view_t view)
{
        return (_lgrpsys(LGRP_SYS_GENERATION, view, NULL));
}


/*
 * Get supported revision number of lgroup interface
 */
int
lgrp_version(int version)
{
        return (_lgrpsys(LGRP_SYS_VERSION, version, NULL));
}


/*
 * Get affinity for given lgroup
 */
lgrp_affinity_t
lgrp_affinity_get(idtype_t idtype, id_t id, lgrp_id_t lgrp)
{
        lgrp_affinity_args_t    args;

        args.idtype = idtype;
        args.id = id;
        args.lgrp = lgrp;
        return (_lgrpsys(LGRP_SYS_AFFINITY_GET, 0, (void *)&args));
}


/*
 * Set affinity for given lgroup
 */
int
lgrp_affinity_set(idtype_t idtype, id_t id, lgrp_id_t lgrp,
    lgrp_affinity_t aff)
{
        lgrp_affinity_args_t    args;

        args.idtype = idtype;
        args.id = id;
        args.lgrp = lgrp;
        args.aff = aff;
        return (_lgrpsys(LGRP_SYS_AFFINITY_SET, 0, (void *)&args));
}


/*
 * Get home lgroup for given process or thread
 */
lgrp_id_t
lgrp_home(idtype_t idtype, id_t id)
{
        /*
         * Use fast trap to get home lgroup of current thread or process
         * Otherwise, use system call for other process or thread
         */
        if (id == P_MYID && (idtype == P_LWPID || idtype == P_PID))
                return (_lgrp_home_fast());
        else
                return (_lgrpsys(LGRP_SYS_HOME, idtype, (void *)(intptr_t)id));
}


/*
 * Get a snapshot of the lgroup hierarchy
 */
static int
lgrp_snapshot(void *buf, size_t bufsize)
{
        return (_lgrpsys(LGRP_SYS_SNAPSHOT, bufsize, buf));
}


/*
 * Find any orphan lgroups without parents and make them be children of
 * root lgroup
 */
static int
parent_orphans(lgrp_snapshot_header_t *snap)
{
        int             i;
        lgrp_info_t     *lgrp_info;
        int             nlgrpsmax;
        int             orphan;
        lgrp_info_t     *root;
        ulong_t         *parents;

        if (snap == NULL || snap->ss_info == NULL ||
            snap->ss_parents == NULL || snap->ss_root < 0 ||
            snap->ss_root >= snap->ss_nlgrps_max)
                return (-1);

        nlgrpsmax = snap->ss_nlgrps_max;
        root = &snap->ss_info[snap->ss_root];

        for (i = 0; i < nlgrpsmax; i++) {
                int     j;

                /*
                 * Skip root lgroup
                 */
                if (i == snap->ss_root)
                        continue;

                lgrp_info = &snap->ss_info[i];
                if (lgrp_info == NULL || lgrp_info->info_lgrpid == LGRP_NONE)
                        continue;

                /*
                 * Make sure parents bitmap is setup
                 */
                if (lgrp_info->info_parents == NULL)
                        lgrp_info->info_parents =
                            (ulong_t *)((uintptr_t)snap->ss_parents +
                            (i * BT_SIZEOFMAP(nlgrpsmax)));

                /*
                 * Look for orphans (lgroups with no parents)
                 */
                orphan = 1;
                parents = lgrp_info->info_parents;
                for (j = 0; j < BT_BITOUL(nlgrpsmax); j++)
                        if (parents[j] != 0) {
                                orphan = 0;
                                break;
                        }

                /*
                 * Make root be parent of any orphans
                 */
                if (orphan) {
                        BT_SET(parents, root->info_lgrpid);
                        if (root->info_children) {
                                BT_SET(root->info_children, i);
                        }
                }
        }

        return (0);
}


/*
 * Remove given lgroup from parent lgroup(s)
 */
static void
prune_child(lgrp_snapshot_header_t *snap, lgrp_id_t lgrp)
{
        int             i;
        lgrp_info_t     *lgrp_info;
        ulong_t         *parents;

        if (snap == NULL || lgrp < 0 || lgrp > snap->ss_nlgrps_max)
                return;

        lgrp_info = &snap->ss_info[lgrp];

        parents = lgrp_info->info_parents;
        if (parents == NULL)
                return;

        /*
         * Update children of parents not to include given lgroup
         */
        for (i = 0; i < snap->ss_nlgrps_max; i++) {
                if (BT_TEST(parents, i)) {
                        lgrp_info = &snap->ss_info[i];
                        BT_CLEAR(lgrp_info->info_children, lgrp);
                }
        }
}

/*
 * Prune any CPUs not in given array from specified lgroup
 */
static void
prune_cpus(lgrp_snapshot_header_t *snap, lgrp_id_t lgrp, processorid_t *cpus,
    int ncpus)
{
        int             count;
        int             i;
        int             j;
        int             k;
        lgrp_info_t     *lgrp_info;
        uint_t          lgrp_ncpus;
        processorid_t   *lgrp_cpus;

        if (snap == NULL || lgrp < 0 || lgrp > snap->ss_nlgrps_max)
                return;

        lgrp_info = &snap->ss_info[lgrp];

        /*
         * No CPUs to remove
         */
        if (ncpus == 0 || lgrp_info->info_ncpus == 0)
                return;

        /*
         * Remove all CPUs from lgroup
         */
        if (cpus == NULL && ncpus == -1) {
                lgrp_info->info_ncpus = 0;
                return;
        }

        /*
         * Remove any CPUs from lgroup not in given list of CPUs
         */
        lgrp_cpus = lgrp_info->info_cpuids;
        lgrp_ncpus = lgrp_info->info_ncpus;
        i = 0;
        for (count = 0; count < lgrp_ncpus; count++) {
                /*
                 * Look for CPU in list
                 */
                for (j = 0; j < ncpus; j++)
                        if (lgrp_cpus[i] == cpus[j])
                                break;

                /*
                 * Go to next CPU if found this one in list
                 */
                if (j < ncpus) {
                        i++;
                        continue;
                }

                /*
                 * Remove this CPU and shift others into its place
                 * and decrement number of CPUs
                 */
                for (k = i + 1; k < lgrp_info->info_ncpus; k++)
                        lgrp_cpus[k - 1] = lgrp_cpus[k];
                lgrp_cpus[k - 1] = -1;
                lgrp_info->info_ncpus--;
        }
}


/*
 * Prune lgroup hierarchy for caller's view
 */
static int
prune_tree(lgrp_snapshot_header_t *snap)
{
        processorid_t   *cpus;
        int             i;
        lgrp_info_t     *lgrp_info;
        lgrp_mem_size_t nbytes;
        uint_t          ncpus;
        int             nlgrps_max;

        if (snap == NULL || snap->ss_info == NULL)
                return (-1);

        /*
         * Get CPUs in caller's pset
         */
        if (pset_info(PS_MYID, NULL, &ncpus, NULL) == -1)
                return (-1);

        cpus = NULL;
        if (ncpus > 0) {
                cpus = malloc(ncpus * sizeof (processorid_t));
                if (pset_info(PS_MYID, NULL, &ncpus, cpus) == -1) {
                        free(cpus);
                        return (-1);
                }
        }

        /*
         * Remove any CPUs not in caller's pset from lgroup hierarchy
         */
        nlgrps_max = snap->ss_nlgrps_max;
        for (i = 0; i < nlgrps_max; i++) {
                lgrp_info = &snap->ss_info[i];
                if (BT_TEST(snap->ss_lgrpset, i))
                        prune_cpus(snap, i, cpus, ncpus);
                else if (lgrp_info->info_lgrpid != LGRP_NONE)
                        prune_cpus(snap, i, NULL, -1);
        }

        if (ncpus > 0)
                free(cpus);

        /*
         * Change lgroup bitmask from just reflecting lgroups overlapping
         * caller's pset to all lgroups available to caller, starting by
         * filling in all lgroups and then removing any empty ones below
         */
        for (i = 0; i < nlgrps_max; i++) {
                lgrp_info = &snap->ss_info[i];
                if (lgrp_info->info_lgrpid == LGRP_NONE)
                        continue;

                BT_SET(snap->ss_lgrpset, i);
        }

        /*
         * Remove empty lgroups from lgroup hierarchy, removing it from its
         * parents and decrementing nlgrps
         */
        for (i = 0; i < nlgrps_max; i++) {
                lgrp_info = &snap->ss_info[i];
                if (lgrp_info->info_lgrpid == LGRP_NONE)
                        continue;

                ncpus = lgrp_cpus_hier(snap, i, NULL, NULL);
                nbytes = lgrp_mem_size((lgrp_cookie_t)snap, i,
                    LGRP_MEM_SZ_INSTALLED, LGRP_CONTENT_HIERARCHY);
                if (ncpus == 0 && nbytes == 0) {
                        BT_CLEAR(snap->ss_lgrpset, i);
                        prune_child(snap, i);
                        snap->ss_nlgrps--;
                }
        }

        return (0);
}


/*
 * Initialize lgroup interface
 */
lgrp_cookie_t
lgrp_init(lgrp_view_t view)
{
        ssize_t                 bufsize;
        uint_t                  gen;
        int                     i;
        lgrp_snapshot_header_t  *snap;

        /*
         * Check for legal view
         */
        if (view != LGRP_VIEW_OS && view != LGRP_VIEW_CALLER) {
                errno = EINVAL;
                return (LGRP_COOKIE_NONE);
        }

        /*
         * Try to take a consistent snapshot of lgroup hierarchy
         */
        snap = NULL;
        while (snap == NULL) {
                /*
                 * Get lgroup generation number before taking snapshot
                 */
                gen = lgrp_generation(view);

                /*
                 * Get size of buffer needed for snapshot
                 */
                bufsize = lgrp_snapshot(NULL, 0);
                if (bufsize <= 0) {
                        if (errno == ENOMEM)
                                return (LGRP_COOKIE_NONE);

                        snap = NULL;
                        continue;
                }

                /*
                 * Allocate buffer
                 */
                snap = malloc(bufsize);
                if (snap == NULL)
                        return (LGRP_COOKIE_NONE);
                bzero(snap, bufsize);

                /*
                 * Take snapshot of lgroup hierarchy
                 */
                bufsize = lgrp_snapshot(snap, bufsize);
                if (bufsize <= 0) {
                        free(snap);
                        if (errno == ENOMEM)
                                return (LGRP_COOKIE_NONE);

                        snap = NULL;
                        continue;
                }

                /*
                 * See whether lgroup generation number changed
                 */
                if (gen == lgrp_generation(view))
                        break;

                free(snap);
                snap = NULL;
        }

        /*
         * Remember generation number and view of this snapshot
         */
        snap->ss_gen = gen;
        snap->ss_view = view;

        /*
         * Keep caller's pset ID for caller's view
         */
        snap->ss_pset = 0;
        if (view == LGRP_VIEW_CALLER) {
                psetid_t        pset;

                if (pset_bind(PS_QUERY, P_LWPID, P_MYID, &pset) == -1)
                        return ((uintptr_t)-1);

                snap->ss_pset = pset;
        }

        /*
         * Find any orphan lgroups without parents and make them be children
         * of the root lgroup
         */
        if (snap->ss_levels > 1)
                (void) parent_orphans(snap);

        /*
         * Prune snapshot of lgroup hierarchy for caller's view
         */
        if (view == LGRP_VIEW_CALLER)
                (void) prune_tree(snap);
        else {
                /*
                 * Change lgroup bitmask from just reflecting lgroups
                 * overlapping caller's pset to all lgroups available
                 */
                for (i = 0; i < snap->ss_nlgrps_max; i++) {
                        lgrp_info_t     *lgrp_info;

                        lgrp_info = &snap->ss_info[i];
                        if (lgrp_info->info_lgrpid == LGRP_NONE)
                                continue;

                        BT_SET(snap->ss_lgrpset, i);
                }
        }

        return ((uintptr_t)snap);
}


/*
 * Return whether given cookie is out-of-date (stale) or not
 */
int
lgrp_cookie_stale(lgrp_cookie_t cookie)
{
        psetid_t                pset;
        lgrp_snapshot_header_t  *snap;

        /*
         * Check for bad cookie
         */
        snap = (lgrp_snapshot_header_t *)cookie;
        if (snap == NULL || snap->ss_magic != cookie) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * Check generation number which changes when lgroup hierarchy changes
         * or pset contents change for caller's view
         */
        if (snap->ss_gen != lgrp_generation(snap->ss_view))
                return (1);

        /*
         * See whether pset binding has changed for caller's view
         */
        if (snap->ss_view == LGRP_VIEW_CALLER) {
                if (pset_bind(PS_QUERY, P_LWPID, P_MYID, &pset) == -1)
                        return (-1);
                if (snap->ss_pset != pset)
                        return (1);
        }

        return (0);     /* cookie isn't stale */
}


/*
 * Get view of lgroup hierarchy from snapshot represented by given cookie
 */
lgrp_view_t
lgrp_view(lgrp_cookie_t cookie)
{
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;
        if (snap == NULL || snap->ss_magic != cookie) {
                errno = EINVAL;
                return (-1);
        }

        return (snap->ss_view);
}


/*
 * Get number of lgroups
 */
int
lgrp_nlgrps(lgrp_cookie_t cookie)
{
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        if (snap == NULL || snap->ss_magic != cookie) {
                errno = EINVAL;
                return (-1);
        }

        return (snap->ss_nlgrps);
}


/*
 * Return root lgroup ID
 */
lgrp_id_t
lgrp_root(lgrp_cookie_t cookie)
{
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        if (snap == NULL || snap->ss_magic != cookie) {
                errno = EINVAL;
                return (-1);
        }

        return (snap->ss_root);
}


/*
 * Get parent lgroups of given lgroup
 */
int
lgrp_parents(lgrp_cookie_t cookie, lgrp_id_t lgrp, lgrp_id_t *parents,
    uint_t count)
{
        int                     i;
        ulong_t                 *lgrp_parents;
        lgrp_snapshot_header_t  *snap;
        int                     nlgrps_max;
        int                     nparents;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid arguments
         */
        if (snap == NULL || snap->ss_magic != cookie ||
            lgrp < 0 || lgrp == LGRP_NONE) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * See whether given lgroup exists
         */
        nlgrps_max = snap->ss_nlgrps_max;
        if (lgrp >= nlgrps_max || !BT_TEST(snap->ss_lgrpset, lgrp)) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * No parents, since given lgroup is root lgroup or
         * only one level in lgroup hierarchy (ie. SMP)
         */
        if (lgrp == snap->ss_root || snap->ss_levels == 1) {
                if (parents == NULL || count < 1)
                        return (0);
                return (0);
        }

        /*
         * Make sure that parents exist
         */
        if (snap->ss_parents == NULL) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Given lgroup should have a parent
         */
        lgrp_parents = &snap->ss_parents[lgrp * BT_BITOUL(nlgrps_max)];
        if (lgrp_parents == NULL) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Check lgroup parents bitmask, fill in parents array, and return
         * number of parents
         */
        nparents = 0;
        for (i = 0; i < nlgrps_max; i++) {
                if (BT_TEST(lgrp_parents, i)) {
                        if (parents != NULL && nparents < count) {
                                parents[nparents] = i;
                        }
                        nparents++;
                }
        }
        return (nparents);
}


/*
 * Get children lgroups of given lgroup
 */
int
lgrp_children(lgrp_cookie_t cookie, lgrp_id_t lgrp, lgrp_id_t *children,
    uint_t count)
{
        int                     i;
        ulong_t                 *lgrp_children;
        int                     nlgrps_max;
        int                     nchildren;
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid arguments
         */
        if (snap == NULL || snap->ss_magic != cookie ||
            lgrp < 0 || lgrp == LGRP_NONE) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * See whether given lgroup exists
         */
        nlgrps_max = snap->ss_nlgrps_max;
        if (lgrp >= nlgrps_max || !BT_TEST(snap->ss_lgrpset, lgrp)) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * No children, since only one level in lgroup hierarchy (ie. SMP)
         */
        if (snap->ss_levels == 1) {
                if (children == NULL || count < 1)
                        return (0);
                return (0);
        }

        /*
         * Make sure that children exist
         */
        if (snap->ss_children == NULL) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Given lgroup may not have any children
         */
        lgrp_children = &snap->ss_children[lgrp * BT_BITOUL(nlgrps_max)];

        if (lgrp_children == NULL)
                return (0);

        /*
         * Check lgroup children bitmask, fill in children array, and return
         * number of children
         */
        nchildren = 0;
        for (i = 0; i < nlgrps_max; i++) {
                if (BT_TEST(lgrp_children, i)) {
                        if (children != NULL && nchildren < count)
                                children[nchildren] = i;
                        nchildren++;
                }
        }
        return (nchildren);
}


/*
 * Get all CPUs within given lgroup (hierarchy)
 */
static int
lgrp_cpus_hier(lgrp_snapshot_header_t *snap, lgrp_id_t lgrp,
    processorid_t **cpuids, uint_t *count)
{
        processorid_t   *cpus;
        int             i;
        int             j;
        lgrp_info_t     *lgrp_info;
        int             ncpus;
        int             nlgrps_max;
        ulong_t         *rset;
        int             total;

        /*
         * Get lgroup info
         */
        lgrp_info = &snap->ss_info[lgrp];

        if (lgrp_info == NULL) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Check whether given lgroup contains any lgroups with CPU resources
         */
        if (lgrp_info->info_rset == NULL)
                return (0);

        nlgrps_max = snap->ss_nlgrps_max;
        rset = &lgrp_info->info_rset[LGRP_RSRC_CPU * BT_BITOUL(nlgrps_max)];

        /*
         * Get all CPUs within this lgroup
         */
        total = 0;
        for (i = 0; i < nlgrps_max; i++) {
                if (!BT_TEST(rset, i))
                        continue;

                lgrp_info = &snap->ss_info[i];

                /*
                 * Get all CPUs within lgroup
                 */
                cpus = lgrp_info->info_cpuids;
                ncpus = lgrp_info->info_ncpus;
                total += ncpus;

                /*
                 * Copy as many CPU IDs into array that will fit
                 * and decrement count and increment array pointer
                 * as we go
                 */
                if (cpuids && *cpuids && count) {
                        for (j = 0; j < ncpus; j++) {
                                if (*count) {
                                        **cpuids = cpus[j];
                                        (*cpuids)++;
                                        (*count)--;
                                }
                        }
                }
        }

        return (total);
}


/*
 * Get CPUs in given lgroup
 */
int
lgrp_cpus(lgrp_cookie_t cookie, lgrp_id_t lgrp, processorid_t *cpuids,
    uint_t count, lgrp_content_t content)
{
        int                     i;
        processorid_t           *cpus;
        lgrp_info_t             *lgrp_info;
        int                     ncpus;
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid arguments
         */
        if (snap == NULL || snap->ss_magic != cookie ||
            lgrp < 0 || lgrp == LGRP_NONE ||
            (content != LGRP_CONTENT_DIRECT &&
            content != LGRP_CONTENT_HIERARCHY)) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * See whether given lgroup exists
         */
        if (lgrp >= snap->ss_nlgrps_max || snap->ss_info == NULL ||
            !BT_TEST(snap->ss_lgrpset, lgrp)) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Get lgroup info
         */
        lgrp_info = &snap->ss_info[lgrp];

        /*
         * Get contents of lgroup
         */
        switch (content) {
        case LGRP_CONTENT_DIRECT:
                /*
                 * Get CPUs contained directly within given lgroup
                 */
                cpus = lgrp_info->info_cpuids;
                ncpus = lgrp_info->info_ncpus;

                /*
                 * No array to copy CPU IDs into,
                 * so just return number of CPUs.
                 */
                if (cpuids == NULL)
                        return (ncpus);

                /*
                 * Copy as many CPU IDs into array that will fit
                 */
                for (i = 0; i < ncpus; i++)
                        if (i < count)
                                cpuids[i] = cpus[i];

                return (ncpus);

        case LGRP_CONTENT_ALL:
                return (lgrp_cpus_hier(snap, lgrp, &cpuids, &count));

        default:
                errno = EINVAL;
                return (-1);
        }
}


/*
 * Return physical memory size in pages for given lgroup
 */
lgrp_mem_size_t
lgrp_mem_size(lgrp_cookie_t cookie, lgrp_id_t lgrp, lgrp_mem_size_flag_t type,
    lgrp_content_t content)
{
        int                     i;
        lgrp_info_t             *lgrp_info;
        int                     nlgrps_max;
        int                     pgsz;
        ulong_t                 *rset;
        lgrp_mem_size_t         size;
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid arguments
         */
        if (snap == NULL || snap->ss_magic != cookie ||
            lgrp < 0 || lgrp == LGRP_NONE) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * See whether given lgroup exists
         */
        nlgrps_max = snap->ss_nlgrps_max;
        if (lgrp >= nlgrps_max || snap->ss_info == NULL ||
            !BT_TEST(snap->ss_lgrpset, lgrp)) {
                errno = ESRCH;
                return (-1);
        }

        pgsz = getpagesize();

        /*
         * Get lgroup info
         */
        lgrp_info = &snap->ss_info[lgrp];

        switch (content) {
        case LGRP_CONTENT_DIRECT:
                /*
                 * Get memory contained directly in this lgroup
                 */
                switch (type) {
                case LGRP_MEM_SZ_FREE:
                        size = (lgrp_mem_size_t)pgsz *
                            lgrp_info->info_mem_free;
                        return (size);
                case LGRP_MEM_SZ_INSTALLED:
                        size = (lgrp_mem_size_t)pgsz *
                            lgrp_info->info_mem_install;
                        return (size);
                default:
                        errno = EINVAL;
                        return (-1);
                }

        case LGRP_CONTENT_ALL:
                /*
                 * Get memory contained within this lgroup (and its children)
                 */
                /*
                 * Check whether given lgroup contains any lgroups with CPU
                 * resources
                 */
                if (lgrp_info->info_rset == NULL)
                        return (0);

                rset = &lgrp_info->info_rset[LGRP_RSRC_MEM *
                    BT_BITOUL(nlgrps_max)];

                /*
                 * Add up memory in lgroup resources
                 */
                size = 0;
                for (i = 0; i < nlgrps_max; i++) {
                        if (!BT_TEST(rset, i))
                                continue;

                        lgrp_info = &snap->ss_info[i];
                        switch (type) {
                        case LGRP_MEM_SZ_FREE:
                                size += (lgrp_mem_size_t)pgsz *
                                    lgrp_info->info_mem_free;
                                break;
                        case LGRP_MEM_SZ_INSTALLED:
                                size += (lgrp_mem_size_t)pgsz *
                                    lgrp_info->info_mem_install;
                                break;
                        default:
                                errno = EINVAL;
                                return (-1);
                        }

                }

                return (size);

        default:
                errno = EINVAL;
                return (-1);
        }
}


/*
 * Get resources for a particuliar lgroup
 */
int
lgrp_resources(lgrp_cookie_t cookie, lgrp_id_t lgrp, lgrp_id_t *lgrps,
    uint_t count, lgrp_rsrc_t type)
{
        int                     i;
        lgrp_info_t             *lgrp_info;
        int                     nlgrps;
        int                     nlgrps_max;
        ulong_t                 *rset;
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid arguments
         */
        if (snap == NULL || snap->ss_magic != cookie ||
            lgrp < 0 || lgrp == LGRP_NONE ||
            (type != LGRP_RSRC_CPU && type != LGRP_RSRC_MEM)) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * See whether given lgroup exists
         */
        nlgrps_max = snap->ss_nlgrps_max;
        if (lgrp >= nlgrps_max || snap->ss_info == NULL ||
            !BT_TEST(snap->ss_lgrpset, lgrp)) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Get lgroup info
         */
        lgrp_info = &snap->ss_info[lgrp];

        /*
         * Count number lgroups contained within this lgroup and
         * copy as many lgroup IDs into array that will fit
         */
        rset = &lgrp_info->info_rset[type * BT_BITOUL(nlgrps_max)];
        nlgrps = 0;
        for (i = 0; i < snap->ss_nlgrps_max; i++)
                if (BT_TEST(rset, i)) {
                        if (lgrps != NULL && nlgrps < count)
                                lgrps[nlgrps] = i;
                        nlgrps++;
                }

        return (nlgrps);
}


/*
 * Finish using lgroup interface
 */
int
lgrp_fini(lgrp_cookie_t cookie)
{
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        if (snap == NULL || snap->ss_magic != cookie) {
                errno = EINVAL;
                return (-1);
        }

        bzero(snap, snap->ss_size);
        free(snap);
        snap = NULL;

        return (0);
}


/*
 * Return latency between "from" and "to" lgroups
 *
 * This latency number can only be used for relative comparison
 * between lgroups on the running system, cannot be used across platforms,
 * and may not reflect the actual latency.  It is platform and implementation
 * specific, so platform gets to decide its value.  It would be nice if the
 * number was at least proportional to make comparisons more meaningful though.
 */
int
lgrp_latency(lgrp_id_t from, lgrp_id_t to)
{
        lgrp_cookie_t           cookie;
        int                     latency;

        cookie = lgrp_init(LGRP_VIEW_OS);
        latency = lgrp_latency_cookie(cookie, from, to, LGRP_LAT_CPU_TO_MEM);
        (void) lgrp_fini(cookie);

        return (latency);
}


/*
 * Return latency between "from" and "to" lgroups
 *
 * This latency number can only be used for relative comparison
 * between lgroups on the running system, cannot be used across platforms,
 * and may not reflect the actual latency.  It is platform and implementation
 * specific, so platform gets to decide its value.  It would be nice if the
 * number was at least proportional to make comparisons more meaningful though.
 */
int
lgrp_latency_cookie(lgrp_cookie_t cookie, lgrp_id_t from, lgrp_id_t to,
    lgrp_lat_between_t between)
{
        lgrp_info_t             *lgrp_info;
        lgrp_mem_size_t         nbytes;
        int                     ncpus;
        int                     nlgrps_max;
        lgrp_snapshot_header_t  *snap;

        snap = (lgrp_snapshot_header_t *)cookie;

        /*
         * Check for valid snapshot, lgroup, and between flag
         */
        if (snap == NULL || snap->ss_magic != cookie || from < 0 || to < 0 ||
            between != LGRP_LAT_CPU_TO_MEM) {
                errno = EINVAL;
                return (-1);
        }

        /*
         * Check whether lgroups exist
         */
        nlgrps_max = snap->ss_nlgrps_max;
        if (from >= nlgrps_max || to >= nlgrps_max) {
                errno = ESRCH;
                return (-1);
        }

        /*
         * Check whether "from" lgroup has any CPUs
         */
        ncpus = lgrp_cpus(cookie, from, NULL, 0, LGRP_CONTENT_HIERARCHY);
        if (ncpus <= 0) {
                if (ncpus == 0)
                        errno = ESRCH;
                return (-1);
        }

        /*
         * Check whether "to" lgroup has any memory
         */
        nbytes = lgrp_mem_size(cookie, to, LGRP_MEM_SZ_INSTALLED,
            LGRP_CONTENT_HIERARCHY);
        if (nbytes <= 0) {
                if (nbytes == 0)
                        errno = ESRCH;
                return (-1);
        }

        if (from == to) {
                lgrp_info = &snap->ss_info[from];
                return (lgrp_info->info_latency);
        }

        return (snap->ss_latencies[from][to]);
}