/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/sysmacros.h>
#include <sys/note.h>
#include <fcntl.h>
#include <errno.h>
#include <assert.h>
#include <libgen.h>
#include <kstat.h>
#include <ofmt.h>
#include <libilb.h>
#include "ilbadm.h"

#define ILBST_TIMESTAMP_HEADER  0x01    /* a timestamp w. every header */
#define ILBST_DELTA_INTERVAL    0x02    /* delta over specified interval */
#define ILBST_ABS_NUMBERS       0x04    /* print absolute numbers, no d's */
#define ILBST_ITEMIZE           0x08    /* itemize */
#define ILBST_VERBOSE           0x10    /* verbose error info */

#define ILBST_OLD_VALUES        0x20    /* for internal processing */
#define ILBST_RULES_CHANGED     0x40

typedef struct {
        char            is_name[KSTAT_STRLEN];
        uint64_t        is_value;
} ilbst_stat_t;

static ilbst_stat_t rulestats[] = {
        {"num_servers", 0},
        {"bytes_not_processed", 0},
        {"pkt_not_processed", 0},
        {"bytes_dropped", 0},
        {"pkt_dropped", 0},
        {"nomem_bytes_dropped", 0},
        {"nomem_pkt_dropped", 0},
        {"noport_bytes_dropped", 0},
        {"noport_pkt_dropped", 0},
        {"icmp_echo_processed", 0},
        {"icmp_dropped", 0},
        {"icmp_too_big_processed", 0},
        {"icmp_too_big_dropped", 0}
};

/* indices into array above, to avoid searching */
#define RLSTA_NUM_SRV           0
#define RLSTA_BYTES_U           1
#define RLSTA_PKT_U             2
#define RLSTA_BYTES_D           3
#define RLSTA_PKT_D             4
#define RLSTA_NOMEMBYTES_D      5
#define RLSTA_NOMEMPKT_D        6
#define RLSTA_NOPORTBYTES_D     7
#define RLSTA_NOPORTPKT_D       8
#define RLSTA_ICMP_P            9
#define RLSTA_ICMP_D            10
#define RLSTA_ICMP2BIG_P        11
#define RLSTA_ICMP2BIG_D        12

static ilbst_stat_t servstats[] = {
        {"bytes_processed", 0},
        {"pkt_processed", 0}
};
/* indices into array above, to avoid searching */
#define SRVST_BYTES_P   0
#define SRVST_PKT_P     1

/* values used for of_* commands as id */
#define ILBST_PKT_P             0
#define ILBST_BYTES_P           1
#define ILBST_PKT_U             2
#define ILBST_BYTES_U           3
#define ILBST_PKT_D             4
#define ILBST_BYTES_D           5
#define ILBST_ICMP_P            6
#define ILBST_ICMP_D            7
#define ILBST_ICMP2BIG_P        8
#define ILBST_ICMP2BIG_D        9
#define ILBST_NOMEMP_D          10
#define ILBST_NOPORTP_D         11
#define ILBST_NOMEMB_D          12
#define ILBST_NOPORTB_D         13

#define ILBST_ITEMIZE_SNAME     97
#define ILBST_ITEMIZE_RNAME     98
#define ILBST_TIMESTAMP         99

/* approx field widths */
#define ILBST_PKTCTR_W          8
#define ILBST_BYTECTR_W         10
#define ILBST_TIME_W            15

static boolean_t of_rule_stats(ofmt_arg_t *, char *, uint_t);
static boolean_t of_server_stats(ofmt_arg_t *, char *, uint_t);
static boolean_t of_itemize_stats(ofmt_arg_t *, char *, uint_t);
static boolean_t of_timestamp(ofmt_arg_t *, char *, uint_t);

static ofmt_field_t stat_itemize_fields[] = {
        {"RULENAME", ILB_NAMESZ,        ILBST_ITEMIZE_RNAME, of_itemize_stats},
        {"SERVERNAME", ILB_NAMESZ,      ILBST_ITEMIZE_SNAME, of_itemize_stats},
        {"PKT_P",   ILBST_PKTCTR_W,     ILBST_PKT_P, of_itemize_stats},
        {"BYTES_P", ILBST_BYTECTR_W,    ILBST_BYTES_P, of_itemize_stats},
        {"TIME",    ILBST_TIME_W,       ILBST_TIMESTAMP, of_timestamp},
        {NULL,      0, 0, NULL}
};
static ofmt_field_t stat_stdfields[] = {
        {"PKT_P",   ILBST_PKTCTR_W,     ILBST_PKT_P, of_server_stats},
        {"BYTES_P", ILBST_BYTECTR_W,    ILBST_BYTES_P, of_server_stats},
        {"PKT_U",   ILBST_PKTCTR_W,     ILBST_PKT_U, of_rule_stats},
        {"BYTES_U", ILBST_BYTECTR_W,    ILBST_BYTES_U, of_rule_stats},
        {"PKT_D",   ILBST_PKTCTR_W,     ILBST_PKT_D, of_rule_stats},
        {"BYTES_D", ILBST_BYTECTR_W,    ILBST_BYTES_D, of_rule_stats},
        {"ICMP_P",  ILBST_PKTCTR_W,     ILBST_ICMP_P, of_rule_stats},
        {"ICMP_D",  ILBST_PKTCTR_W,     ILBST_ICMP_D, of_rule_stats},
        {"ICMP2BIG_P", 11,              ILBST_ICMP2BIG_P, of_rule_stats},
        {"ICMP2BIG_D", 11,              ILBST_ICMP2BIG_D, of_rule_stats},
        {"NOMEMP_D", ILBST_PKTCTR_W,    ILBST_NOMEMP_D, of_rule_stats},
        {"NOPORTP_D", ILBST_PKTCTR_W,   ILBST_NOPORTP_D, of_rule_stats},
        {"NOMEMB_D", ILBST_PKTCTR_W,    ILBST_NOMEMB_D, of_rule_stats},
        {"NOPORTB_D", ILBST_PKTCTR_W,   ILBST_NOPORTB_D, of_rule_stats},
        {"TIME",    ILBST_TIME_W,       ILBST_TIMESTAMP, of_timestamp},
        {NULL,      0, 0, NULL}
};

static char stat_stdhdrs[] = "PKT_P,BYTES_P,PKT_U,BYTES_U,PKT_D,BYTES_D";
static char stat_stdv_hdrs[] = "PKT_P,BYTES_P,PKT_U,BYTES_U,PKT_D,BYTES_D,"
        "ICMP_P,ICMP_D,ICMP2BIG_P,ICMP2BIG_D,NOMEMP_D,NOPORTP_D";
static char stat_itemize_rule_hdrs[] = "SERVERNAME,PKT_P,BYTES_P";
static char stat_itemize_server_hdrs[] = "RULENAME,PKT_P,BYTES_P";

#define RSTAT_SZ        (sizeof (rulestats)/sizeof (rulestats[0]))
#define SSTAT_SZ        (sizeof (servstats)/sizeof (servstats[0]))

typedef struct {
        char            isd_servername[KSTAT_STRLEN]; /* serverID */
        ilbst_stat_t    isd_serverstats[SSTAT_SZ];
        hrtime_t        isd_crtime;     /* save for comparison purpose */
} ilbst_srv_desc_t;

/*
 * this data structure stores statistics for a rule - both an old set
 * and a current/new set. we use pointers to the actual stores and switch
 * the pointers for every round. old_is_old in ilbst_arg_t indicates
 * which pointer points to the "old" data struct (ie, if true, _o pointer
 * points to old)
 */
typedef struct {
        char                    ird_rulename[KSTAT_STRLEN];
        int                     ird_num_servers;
        int                     ird_num_servers_o;
        int                     ird_srv_ind;
        hrtime_t                ird_crtime;     /* save for comparison */
        hrtime_t                ird_crtime_o;   /* save for comparison */
        ilbst_srv_desc_t        *ird_srvlist;
        ilbst_srv_desc_t        *ird_srvlist_o;
        ilbst_stat_t            ird_rstats[RSTAT_SZ];
        ilbst_stat_t            ird_rstats_o[RSTAT_SZ];
        ilbst_stat_t            *ird_rulestats;
        ilbst_stat_t            *ird_rulestats_o;
} ilbst_rule_desc_t;

/*
 * overall "container" for information pertaining to statistics, and
 * how to display them.
 */
typedef struct {
        int                     ilbst_flags;
        /* fields representing user input */
        char                    *ilbst_rulename;        /* optional */
        char                    *ilbst_server;  /* optional */
        int                     ilbst_interval;
        int                     ilbst_count;
        /* "internal" fields for data and data presentation */
        ofmt_handle_t           ilbst_oh;
        boolean_t               ilbst_old_is_old;
        ilbst_rule_desc_t       *ilbst_rlist;
        int                     ilbst_rcount;     /* current list count */
        int                     ilbst_rcount_prev; /* prev (different) count */
        int                     ilbst_rlist_sz; /* number of alloc'ed rules */
        int                     ilbst_rule_index; /* for itemizes display */
} ilbst_arg_t;

/* ARGSUSED */
static boolean_t
of_timestamp(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        time_t          now;
        struct tm       *now_tm;

        now = time(NULL);
        now_tm = localtime(&now);

        (void) strftime(buf, bufsize, "%F:%H.%M.%S", now_tm);
        return (B_TRUE);
}

static boolean_t
i_sum_per_rule_processed(ilbst_rule_desc_t *rp, uint64_t *resp, int index,
    int flags)
{
        int                     i, num_servers;
        ilbst_srv_desc_t        *srv, *o_srv, *n_srv;
        uint64_t                res = 0;
        boolean_t               valid = B_TRUE;
        boolean_t               old = flags & ILBST_OLD_VALUES;
        boolean_t               check_valid;

        /* if we do abs. numbers, we never look at the _o fields */
        assert((old && (flags & ILBST_ABS_NUMBERS)) == B_FALSE);

        /* we only check for validity under certain conditions */
        check_valid = !(old || (flags & ILBST_ABS_NUMBERS));

        if (check_valid && rp->ird_num_servers != rp->ird_num_servers_o)
                valid = B_FALSE;

        num_servers = old ? rp->ird_num_servers_o : rp->ird_num_servers;

        for (i = 0; i < num_servers; i++) {
                n_srv = &rp->ird_srvlist[i];
                o_srv = &rp->ird_srvlist_o[i];

                if (old)
                        srv = o_srv;
                else
                        srv = n_srv;

                res += srv->isd_serverstats[index].is_value;
                /*
                 * if creation times don't match, comparison is wrong; if
                 * if we already know something is invalid, we don't
                 * need to compare again.
                 */
                if (check_valid && valid == B_TRUE &&
                    o_srv->isd_crtime != n_srv->isd_crtime) {
                        valid = B_FALSE;
                        break;
                }
        }
        /*
         * save the result even though it may be imprecise  - let the
         * caller decide what to do
         */
        *resp = res;

        return (valid);
}

typedef boolean_t (*sumfunc_t)(ilbst_rule_desc_t *, uint64_t *, int);

static boolean_t
i_sum_per_rule_pkt_p(ilbst_rule_desc_t *rp, uint64_t *resp, int flags)
{
        return (i_sum_per_rule_processed(rp, resp, SRVST_PKT_P, flags));
}

static boolean_t
i_sum_per_rule_bytes_p(ilbst_rule_desc_t *rp, uint64_t *resp, int flags)
{
        return (i_sum_per_rule_processed(rp, resp, SRVST_BYTES_P, flags));
}

static boolean_t
of_server_stats(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        ilbst_arg_t     *sta = (ilbst_arg_t *)of_arg->ofmt_cbarg;
        uint64_t        count = 0, val;
        int             i;
        boolean_t       valid = B_TRUE;
        sumfunc_t       sumfunc;

        switch (of_arg->ofmt_id) {
        case ILBST_PKT_P: sumfunc = i_sum_per_rule_pkt_p;
                break;
        case ILBST_BYTES_P: sumfunc = i_sum_per_rule_bytes_p;
                break;
        }

        for (i = 0; i < sta->ilbst_rcount; i++) {
                valid = sumfunc(&sta->ilbst_rlist[i], &val, sta->ilbst_flags);
                if (!valid)
                        return (valid);
                count += val;
        }

        if ((sta->ilbst_flags & ILBST_ABS_NUMBERS) != 0)
                goto out;

        for (i = 0; i < sta->ilbst_rcount; i++) {
                (void) sumfunc(&sta->ilbst_rlist[i], &val,
                    sta->ilbst_flags | ILBST_OLD_VALUES);
                count -= val;
        }

out:
        /*
         * normally, we print "change per second", which we calculate
         * here. otherwise, we print "change over interval"
         */
        if ((sta->ilbst_flags & (ILBST_DELTA_INTERVAL|ILBST_ABS_NUMBERS)) == 0)
                count /= sta->ilbst_interval;

        (void) snprintf(buf, bufsize, "%llu", count);
        return (B_TRUE);
}

/*
 * this function is called when user wants itemized stats of every
 * server for a named rule, or vice vera.
 * i_do_print sets sta->rule_index and the proper ird_srv_ind so
 * we don't have to differentiate between these two cases here.
 */
static boolean_t
of_itemize_stats(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        ilbst_arg_t     *sta = (ilbst_arg_t *)of_arg->ofmt_cbarg;
        int             stat_ind;
        uint64_t        count;
        int             rule_index = sta->ilbst_rule_index;
        int             srv_ind = sta->ilbst_rlist[rule_index].ird_srv_ind;
        boolean_t       ret = B_TRUE;
        ilbst_srv_desc_t *srv, *osrv;

        srv = &sta->ilbst_rlist[rule_index].ird_srvlist[srv_ind];

        switch (of_arg->ofmt_id) {
        case ILBST_PKT_P: stat_ind = SRVST_PKT_P;
                break;
        case ILBST_BYTES_P: stat_ind = SRVST_BYTES_P;
                break;
        case ILBST_ITEMIZE_RNAME:
                (void) snprintf(buf, bufsize, "%s",
                    sta->ilbst_rlist[rule_index].ird_rulename);
                return (B_TRUE);
        case ILBST_ITEMIZE_SNAME:
                (void) snprintf(buf, bufsize, "%s", srv->isd_servername);
                return (B_TRUE);
        }

        count = srv->isd_serverstats[stat_ind].is_value;

        if ((sta->ilbst_flags & ILBST_ABS_NUMBERS) != 0)
                goto out;

        osrv = &sta->ilbst_rlist[rule_index].ird_srvlist_o[srv_ind];
        if (srv->isd_crtime != osrv->isd_crtime)
                ret = B_FALSE;

        count -= osrv->isd_serverstats[stat_ind].is_value;
out:
        /*
         * normally, we print "change per second", which we calculate
         * here. otherwise, we print "change over interval" or absolute
         * values.
         */
        if ((sta->ilbst_flags & (ILBST_DELTA_INTERVAL|ILBST_ABS_NUMBERS)) == 0)
                count /= sta->ilbst_interval;

        (void) snprintf(buf, bufsize, "%llu", count);
        return (ret);

}

static boolean_t
of_rule_stats(ofmt_arg_t *of_arg, char *buf, uint_t bufsize)
{
        ilbst_arg_t     *sta = (ilbst_arg_t *)of_arg->ofmt_cbarg;
        int             i, ind;
        uint64_t        count = 0;

        switch (of_arg->ofmt_id) {
        case ILBST_PKT_U: ind = RLSTA_PKT_U;
                break;
        case ILBST_BYTES_U: ind = RLSTA_BYTES_U;
                break;
        case ILBST_PKT_D: ind = RLSTA_PKT_D;
                break;
        case ILBST_BYTES_D: ind = RLSTA_BYTES_D;
                break;
        case ILBST_ICMP_P: ind = RLSTA_ICMP_P;
                break;
        case ILBST_ICMP_D: ind = RLSTA_ICMP_D;
                break;
        case ILBST_ICMP2BIG_P: ind = RLSTA_ICMP2BIG_P;
                break;
        case ILBST_ICMP2BIG_D: ind = RLSTA_ICMP2BIG_D;
                break;
        case ILBST_NOMEMP_D: ind  = RLSTA_NOMEMPKT_D;
                break;
        case ILBST_NOPORTP_D: ind = RLSTA_NOPORTPKT_D;
                break;
        case ILBST_NOMEMB_D: ind = RLSTA_NOMEMBYTES_D;
                break;
        case ILBST_NOPORTB_D: ind = RLSTA_NOPORTBYTES_D;
                break;
        }

        for (i = 0; i < sta->ilbst_rcount; i++)
                count += sta->ilbst_rlist[i].ird_rulestats[ind].is_value;

        if ((sta->ilbst_flags & ILBST_ABS_NUMBERS) != 0)
                goto out;

        /*
         * the purist approach: if we can't say 100% that what we
         * calculate is correct, don't.
         */
        if (sta->ilbst_flags & ILBST_RULES_CHANGED)
                return (B_FALSE);

        for (i = 0; i < sta->ilbst_rcount; i++) {
                if (sta->ilbst_rlist[i].ird_crtime_o != 0 &&
                    sta->ilbst_rlist[i].ird_crtime !=
                    sta->ilbst_rlist[i].ird_crtime_o)
                        return (B_FALSE);

                count -= sta->ilbst_rlist[i].ird_rulestats_o[ind].is_value;
        }
out:
        /*
         * normally, we print "change per second", which we calculate
         * here. otherwise, we print "change over interval"
         */
        if ((sta->ilbst_flags & (ILBST_DELTA_INTERVAL|ILBST_ABS_NUMBERS)) == 0)
                count /= sta->ilbst_interval;

        (void) snprintf(buf, bufsize, "%llu", count);
        return (B_TRUE);
}

/*
 * Get the number of kstat instances. Note that when rules are being
 * drained the number of kstats instances may be different than the
 * kstat counter num_rules (ilb:0:global:num_rules").
 *
 * Also there can be multiple instances of a rule in the following
 * scenario:
 *
 * A rule named rule A has been deleted but remains in kstats because
 * its undergoing connection draining. During this time, the user adds
 * a new rule with the same name(rule A). In this case, there would
 * be two kstats instances for rule A. Currently ilbadm's aggregate
 * results will include data from both instances of rule A. In,
 * future we should have ilbadm stats only consider the latest instance
 * of the rule (ie only consider the the instance that corresponds
 * to the rule that was just added).
 *
 */
static int
i_get_num_kinstances(kstat_ctl_t *kctl)
{
        kstat_t         *kp;
        int             num_instances = 0; /* nothing found, 0 rules */

        for (kp = kctl->kc_chain; kp != NULL; kp = kp->ks_next) {
                if (strncmp("rulestat", kp->ks_class, 8) == 0 &&
                    strncmp("ilb", kp->ks_module, 3) == 0) {
                        num_instances++;
                }
        }

        return (num_instances);
}


/*
 * since server stat's classname is made up of <rulename>-sstat,
 * we walk the rule list to construct the comparison
 * Return:      pointer to rule whose name matches the class
 *              NULL if no match
 */
static ilbst_rule_desc_t *
match_2_rnames(char *class, ilbst_rule_desc_t *rlist, int rcount)
{
        int i;
        char    classname[KSTAT_STRLEN];

        for (i = 0; i < rcount; i++) {
                (void) snprintf(classname, sizeof (classname), "%s-sstat",
                    rlist[i].ird_rulename);
                if (strncmp(classname, class, sizeof (classname)) == 0)
                        return (&rlist[i]);
        }
        return (NULL);
}

static int
i_stat_index(kstat_named_t *knp, ilbst_stat_t *stats, int count)
{
        int     i;

        for (i = 0; i < count; i++) {
                if (strcasecmp(stats[i].is_name, knp->name) == 0)
                        return (i);
        }

        return (-1);
}

static void
i_copy_sstats(ilbst_srv_desc_t *sp, kstat_t *kp)
{
        kstat_named_t   *knp;
        int             i, ind;

        knp = KSTAT_NAMED_PTR(kp);
        for (i = 0; i < kp->ks_ndata; i++, knp++) {
                ind = i_stat_index(knp, servstats, SSTAT_SZ);
                if (ind == -1)
                        continue;
                (void) strlcpy(sp->isd_serverstats[ind].is_name, knp->name,
                    sizeof (sp->isd_serverstats[ind].is_name));
                sp->isd_serverstats[ind].is_value = knp->value.ui64;
                sp->isd_crtime = kp->ks_crtime;
        }
}


static ilbadm_status_t
i_get_server_descs(ilbst_arg_t *sta, kstat_ctl_t *kctl)
{
        ilbadm_status_t rc = ILBADM_OK;
        kstat_t         *kp;
        int             i = -1;
        ilbst_rule_desc_t       *rp;
        ilbst_rule_desc_t       *rlist = sta->ilbst_rlist;
        int                     rcount = sta->ilbst_rcount;

        /*
         * find all "server" kstats, or the one specified in
         * sta->server
         */
        for (kp = kctl->kc_chain; kp != NULL; kp = kp->ks_next) {
                if (strncmp("ilb", kp->ks_module, 3) != 0)
                        continue;
                if (sta->ilbst_server != NULL &&
                    strcasecmp(sta->ilbst_server, kp->ks_name) != 0)
                        continue;
                rp = match_2_rnames(kp->ks_class, rlist, rcount);
                if (rp == NULL)
                        continue;

                (void) kstat_read(kctl, kp, NULL);
                i = rp->ird_srv_ind++;

                rc = ILBADM_OK;
                /*
                 * This means that a server is added after we check last
                 * time...  Just make the array bigger.
                 */
                if (i+1 > rp->ird_num_servers) {
                        ilbst_srv_desc_t  *srvlist;

                        if ((srvlist = realloc(rp->ird_srvlist, (i+1) *
                            sizeof (*srvlist))) == NULL) {
                                rc = ILBADM_ENOMEM;
                                break;
                        }
                        rp->ird_srvlist = srvlist;
                        rp->ird_num_servers = i;
                }

                (void) strlcpy(rp->ird_srvlist[i].isd_servername, kp->ks_name,
                    sizeof (rp->ird_srvlist[i].isd_servername));
                i_copy_sstats(&rp->ird_srvlist[i], kp);
        }

        for (i = 0; i < rcount; i++)
                rlist[i].ird_srv_ind = 0;

        if (sta->ilbst_server != NULL && i == -1)
                rc = ILBADM_ENOSERVER;
        return (rc);
}

static void
i_copy_rstats(ilbst_rule_desc_t *rp, kstat_t *kp)
{
        kstat_named_t   *knp;
        int             i, ind;

        knp = KSTAT_NAMED_PTR(kp);
        for (i = 0; i < kp->ks_ndata; i++, knp++) {
                ind = i_stat_index(knp, rulestats, RSTAT_SZ);
                if (ind == -1)
                        continue;

                (void) strlcpy(rp->ird_rulestats[ind].is_name, knp->name,
                    sizeof (rp->ird_rulestats[ind].is_name));
                rp->ird_rulestats[ind].is_value = knp->value.ui64;
        }
}

static void
i_set_rlstats_ptr(ilbst_rule_desc_t *rp, boolean_t old_is_old)
{
        if (old_is_old) {
                rp->ird_rulestats = rp->ird_rstats;
                rp->ird_rulestats_o = rp->ird_rstats_o;
        } else {
                rp->ird_rulestats = rp->ird_rstats_o;
                rp->ird_rulestats_o = rp->ird_rstats;
        }
}
/*
 * this function walks the array of rules and switches pointer to old
 * and new stats as well as serverlists.
 */
static void
i_swap_rl_pointers(ilbst_arg_t *sta, int rcount)
{
        int                     i, tmp_num;
        ilbst_rule_desc_t       *rlist = sta->ilbst_rlist;
        ilbst_srv_desc_t        *tmp_srv;

        for (i = 0; i < rcount; i++) {
                /* swap srvlist pointers */
                tmp_srv = rlist[i].ird_srvlist;
                rlist[i].ird_srvlist = rlist[i].ird_srvlist_o;
                rlist[i].ird_srvlist_o = tmp_srv;

                /*
                 * swap server counts - we need the old one to
                 * save reallocation calls
                 */
                tmp_num = rlist[i].ird_num_servers_o;
                rlist[i].ird_num_servers_o = rlist[i].ird_num_servers;
                rlist[i].ird_num_servers = tmp_num;

                /* preserve creation time */
                rlist[i].ird_crtime_o = rlist[i].ird_crtime;

                i_set_rlstats_ptr(&rlist[i], sta->ilbst_old_is_old);
                rlist[i].ird_srv_ind = 0;
        }
}

static void
i_init_rulelist(ilbst_arg_t *sta, int rcount)
{
        int                      i;
        ilbst_rule_desc_t       *rlist = sta->ilbst_rlist;

        for (i = 0; i < rcount; i++) {
                rlist[i].ird_rulestats = rlist[i].ird_rstats;
                rlist[i].ird_rulestats_o = rlist[i].ird_rstats_o;
                rlist[i].ird_srv_ind = 0;
        }
}


/*
 * this function searches for kstats describing individual rules and
 * saves name, # of servers, and the kstat_t * describing them (this is
 * for sta->rulename == NULL);
 * if sta->rulename != NULL, it names the rule we're looking for
 * and this function will fill in the other data (like the all_rules case)
 * Returns:     ILBADM_ENORULE  named rule not found
 *              ILBADM_ENOMEM   no mem. available
 */
static ilbadm_status_t
i_get_rule_descs(ilbst_arg_t *sta, kstat_ctl_t *kctl)
{
        ilbadm_status_t rc = ILBADM_OK;
        kstat_t         *kp;
        kstat_named_t   *knp;
        int             i;
        int             num_servers;
        ilbst_rule_desc_t       *rlist = sta->ilbst_rlist;
        int             rcount = sta->ilbst_rcount;

        /*
         * find all "rule" kstats, or the one specified in
         * sta->ilbst_rulename.
         */
        for (i = 0, kp = kctl->kc_chain; i < rcount && kp != NULL;
            kp = kp->ks_next) {
                if (strncmp("rulestat", kp->ks_class, 8) != 0 ||
                    strncmp("ilb", kp->ks_module, 3) != 0)
                        continue;

                (void) kstat_read(kctl, kp, NULL);

                knp = kstat_data_lookup(kp, "num_servers");
                if (knp == NULL) {
                        ilbadm_err(gettext("kstat_data_lookup() failed: %s"),
                            strerror(errno));
                        rc = ILBADM_LIBERR;
                        break;
                }
                if (sta->ilbst_rulename != NULL) {
                        if (strcasecmp(kp->ks_name, sta->ilbst_rulename)
                            != 0)
                                continue;
                }
                (void) strlcpy(rlist[i].ird_rulename, kp->ks_name,
                    sizeof (rlist[i].ird_rulename));

                /* only alloc the space we need, set counter here ... */
                if (sta->ilbst_server != NULL)
                        num_servers = 1;
                else
                        num_servers = (int)knp->value.ui64;

                /* ... furthermore, only reallocate if necessary */
                if (num_servers != rlist[i].ird_num_servers) {
                        ilbst_srv_desc_t  *srvlist;

                        rlist[i].ird_num_servers = num_servers;

                        if (rlist[i].ird_srvlist == NULL)
                                srvlist = calloc(num_servers,
                                    sizeof (*srvlist));
                        else
                                srvlist = realloc(rlist[i].ird_srvlist,
                                    sizeof (*srvlist) * num_servers);
                        if (srvlist == NULL) {
                                rc = ILBADM_ENOMEM;
                                break;
                        }
                        rlist[i].ird_srvlist = srvlist;
                }
                rlist[i].ird_srv_ind = 0;
                rlist[i].ird_crtime = kp->ks_crtime;

                i_copy_rstats(&rlist[i], kp);
                i++;

                /* if we know we're done, return */
                if (sta->ilbst_rulename != NULL || i == rcount) {
                        rc = ILBADM_OK;
                        break;
                }
        }

        if (sta->ilbst_rulename != NULL && i == 0)
                rc = ILBADM_ENORULE;
        return (rc);
}

static void
i_do_print(ilbst_arg_t *sta)
{
        int     i;

        /* non-itemized display can go right ahead */
        if ((sta->ilbst_flags & ILBST_ITEMIZE) == 0) {
                ofmt_print(sta->ilbst_oh, sta);
                return;
        }

        /*
         * rulename is given, list a line per server
         * here's how we do it:
         *      the _ITEMIZE flag indicates to the print function (called
         *      from ofmt_print()) to look at server [ird_srv_ind] only.
         */
        if (sta->ilbst_rulename != NULL) {
                sta->ilbst_rule_index = 0;
                for (i = 0; i < sta->ilbst_rlist->ird_num_servers; i++) {
                        sta->ilbst_rlist->ird_srv_ind = i;
                        ofmt_print(sta->ilbst_oh, sta);
                }
                sta->ilbst_rlist->ird_srv_ind = 0;
                return;
        }

        /* list one line for every rule for a given server */
        for (i = 0; i < sta->ilbst_rcount; i++) {
                /*
                 * if a rule doesn't contain a given server, there's no
                 * need to print it. Luckily, we can check that
                 * fairly easily
                 */
                if (sta->ilbst_rlist[i].ird_srvlist[0].isd_servername[0] ==
                    '\0')
                        continue;

                sta->ilbst_rule_index = i;
                sta->ilbst_rlist[i].ird_srv_ind = 0;
                ofmt_print(sta->ilbst_oh, sta);
        }
        sta->ilbst_rule_index = 0;
}

static ilbadm_status_t
i_do_show_stats(ilbst_arg_t *sta)
{
        kstat_ctl_t     *kctl;
        kid_t           nkid;
        int             rcount = 1, i;
        ilbadm_status_t rc = ILBADM_OK;
        ilbst_rule_desc_t       *rlist, *rp;
        boolean_t       pseudo_abs = B_FALSE; /* for first pass */

        if ((kctl = kstat_open()) == NULL) {
                ilbadm_err(gettext("kstat_open() failed: %s"), strerror(errno));
                return (ILBADM_LIBERR);
        }


        if (sta->ilbst_rulename == NULL)
                rcount = i_get_num_kinstances(kctl);

        rlist = calloc(sizeof (*rlist), rcount);
        if (rlist == NULL) {
                rc = ILBADM_ENOMEM;
                goto out;
        }

        sta->ilbst_old_is_old = B_TRUE;
        sta->ilbst_rlist = rlist;
        sta->ilbst_rcount = sta->ilbst_rcount_prev = rcount;
        sta->ilbst_rlist_sz = rcount;

        /*
         * in the first pass, we always print absolute numbers. We
         * need to remember whether we wanted abs. numbers for
         * other samples as well
         */
        if ((sta->ilbst_flags & ILBST_ABS_NUMBERS) == 0) {
                sta->ilbst_flags |= ILBST_ABS_NUMBERS;
                pseudo_abs = B_TRUE;
        }

        i_init_rulelist(sta, rcount);
        do {
                rc = i_get_rule_descs(sta, kctl);
                if (rc != ILBADM_OK)
                        goto out;

                rc = i_get_server_descs(sta, kctl);
                if (rc != ILBADM_OK)
                        goto out;

                i_do_print(sta);

                if (sta->ilbst_count == -1 || --(sta->ilbst_count) > 0)
                        (void) sleep(sta->ilbst_interval);
                else
                        break;

                nkid = kstat_chain_update(kctl);
                sta->ilbst_flags &= ~ILBST_RULES_CHANGED;
                /*
                 * we only need to continue with most of the rest of this if
                 * the kstat chain id has changed
                 */
                if (nkid == 0)
                        goto swap_old_new;
                if (nkid == -1) {
                        ilbadm_err(gettext("kstat_chain_update() failed: %s"),
                            strerror(errno));
                        rc = ILBADM_LIBERR;
                        break;
                }

                /*
                 * find out whether the number of rules has changed.
                 * if so, adjust rcount and _o; if number has increased,
                 * expand array to hold all rules.
                 * we only shrink if rlist_sz is larger than both rcount and
                 * rcount_prev;
                 */
                if (sta->ilbst_rulename == NULL)
                        rcount = i_get_num_kinstances(kctl);
                if (rcount != sta->ilbst_rcount) {
                        sta->ilbst_flags |= ILBST_RULES_CHANGED;
                        sta->ilbst_rcount_prev = sta->ilbst_rcount;
                        sta->ilbst_rcount = rcount;

                        if (rcount > sta->ilbst_rcount_prev) {
                                rlist = realloc(sta->ilbst_rlist,
                                    sizeof (*sta->ilbst_rlist) * rcount);
                                if (rlist == NULL) {
                                        rc = ILBADM_ENOMEM;
                                        break;
                                }
                                sta->ilbst_rlist = rlist;
                                /* realloc doesn't zero out memory */
                                for (i = sta->ilbst_rcount_prev;
                                    i < rcount; i++) {
                                        rp = &sta->ilbst_rlist[i];
                                        bzero(rp, sizeof (*rp));
                                        i_set_rlstats_ptr(rp,
                                            sta->ilbst_old_is_old);
                                }
                                /*
                                 * even if rlist_sz was > rcount, it's now
                                 * shrunk to rcount
                                 */
                                sta->ilbst_rlist_sz = sta->ilbst_rcount;
                        }
                }

                /*
                 * we may need to shrink the allocated slots down to the
                 * actually required number - we need to make sure we
                 * don't delete old or new stats.
                 */
                if (sta->ilbst_rlist_sz > MAX(sta->ilbst_rcount,
                    sta->ilbst_rcount_prev)) {
                        sta->ilbst_rlist_sz =
                            MAX(sta->ilbst_rcount, sta->ilbst_rcount_prev);
                        rlist = realloc(sta->ilbst_rlist,
                            sizeof (*sta->ilbst_rlist) * sta->ilbst_rlist_sz);
                        if (rlist == NULL) {
                                rc = ILBADM_ENOMEM;
                                break;
                        }
                        sta->ilbst_rlist = rlist;
                }

                /*
                 * move pointers around so what used to point to "old"
                 * stats now points to new, and vice versa
                 * if we're printing absolute numbers, this rigmarole is
                 * not necessary.
                 */
swap_old_new:
                if (pseudo_abs)
                        sta->ilbst_flags &= ~ILBST_ABS_NUMBERS;

                if ((sta->ilbst_flags & ILBST_ABS_NUMBERS) == 0) {
                        sta->ilbst_old_is_old = !sta->ilbst_old_is_old;
                        i_swap_rl_pointers(sta, rcount);
                }
                _NOTE(CONSTCOND)
        } while (B_TRUE);

out:
        (void) kstat_close(kctl);
        if ((rc != ILBADM_OK) && (rc != ILBADM_LIBERR))
                ilbadm_err(ilbadm_errstr(rc));

        if (sta->ilbst_rlist != NULL)
                free(sta->ilbst_rlist);

        return (rc);
}

/*
 * read ilb's kernel statistics and (periodically) display
 * them.
 */
/* ARGSUSED */
ilbadm_status_t
ilbadm_show_stats(int argc, char *argv[])
{
        ilbadm_status_t rc;
        int             c;
        ilbst_arg_t     sta;
        int             oflags = 0;
        char            *fieldnames = stat_stdhdrs;
        ofmt_field_t    *fields = stat_stdfields;
        boolean_t       r_opt = B_FALSE, s_opt = B_FALSE, i_opt = B_FALSE;
        boolean_t       o_opt = B_FALSE, p_opt = B_FALSE, t_opt = B_FALSE;
        boolean_t       v_opt = B_FALSE, A_opt = B_FALSE, d_opt = B_FALSE;
        ofmt_status_t   oerr;
        ofmt_handle_t   oh = NULL;

        bzero(&sta, sizeof (sta));
        sta.ilbst_interval = 1;
        sta.ilbst_count = 1;

        while ((c = getopt(argc, argv, ":tdAr:s:ivo:p")) != -1) {
                switch ((char)c) {
                case 't': sta.ilbst_flags |= ILBST_TIMESTAMP_HEADER;
                        t_opt = B_TRUE;
                        break;
                case 'd': sta.ilbst_flags |= ILBST_DELTA_INTERVAL;
                        d_opt = B_TRUE;
                        break;
                case 'A': sta.ilbst_flags |= ILBST_ABS_NUMBERS;
                        A_opt = B_TRUE;
                        break;
                case 'r': sta.ilbst_rulename = optarg;
                        r_opt = B_TRUE;
                        break;
                case 's': sta.ilbst_server = optarg;
                        s_opt = B_TRUE;
                        break;
                case 'i': sta.ilbst_flags |= ILBST_ITEMIZE;
                        i_opt = B_TRUE;
                        break;
                case 'o': fieldnames = optarg;
                        o_opt = B_TRUE;
                        break;
                case 'p': oflags |= OFMT_PARSABLE;
                        p_opt = B_TRUE;
                        break;
                case 'v': sta.ilbst_flags |= ILBST_VERBOSE;
                        v_opt = B_TRUE;
                        fieldnames = stat_stdv_hdrs;
                        break;
                case ':': ilbadm_err(gettext("missing option-argument"
                            " detected for %c"), (char)optopt);
                        exit(1);
                        /* not reached */
                        break;
                case '?': /* fallthrough */
                default:
                        unknown_opt(argv, optind-1);
                        /* not reached */
                        break;
                }
        }

        if (s_opt && r_opt) {
                ilbadm_err(gettext("options -s and -r are mutually exclusive"));
                exit(1);
        }

        if (i_opt) {
                if (!(s_opt || r_opt)) {
                        ilbadm_err(gettext("option -i requires"
                            " either -r or -s"));
                        exit(1);
                }
                if (v_opt) {
                        ilbadm_err(gettext("option -i and -v are mutually"
                            " exclusive"));
                        exit(1);
                }
                /* only use "std" headers if none are specified */
                if (!o_opt)
                        if (r_opt)
                                fieldnames = stat_itemize_rule_hdrs;
                        else /* must be s_opt */
                                fieldnames = stat_itemize_server_hdrs;
                fields = stat_itemize_fields;
        }

        if (p_opt) {
                if (!o_opt) {
                        ilbadm_err(gettext("option -p requires -o"));
                        exit(1);
                }
                if (v_opt) {
                        ilbadm_err(gettext("option -o and -v are mutually"
                            " exclusive"));
                        exit(1);
                }
                if (strcasecmp(fieldnames, "all") == 0) {
                        ilbadm_err(gettext("option -p requires"
                            " explicit field names"));
                        exit(1);
                }
        }

        if (t_opt) {
                if (v_opt) {
                        fieldnames = "all";
                } else {
                        int  len = strlen(fieldnames) + 6;
                        char *fnames;

                        fnames = malloc(len);
                        if (fnames == NULL) {
                                rc = ILBADM_ENOMEM;
                                return (rc);
                        }
                        (void) snprintf(fnames, len, "%s,TIME", fieldnames);
                        fieldnames = fnames;
                }
        }

        if (A_opt && d_opt) {
                ilbadm_err(gettext("options -d and -A are mutually exclusive"));
                exit(1);
        }

        /* find and parse interval and count arguments if present */
        if (optind < argc) {
                sta.ilbst_interval = atoi(argv[optind]);
                if (sta.ilbst_interval < 1) {
                        ilbadm_err(gettext("illegal interval spec %s"),
                            argv[optind]);
                        exit(1);
                }
                sta.ilbst_count = -1;
                if (++optind < argc) {
                        sta.ilbst_count = atoi(argv[optind]);
                        if (sta.ilbst_count < 1) {
                                ilbadm_err(gettext("illegal count spec %s"),
                                    argv[optind]);
                                exit(1);
                        }
                }
        }

        oerr = ofmt_open(fieldnames, fields, oflags, 80, &oh);
        if (oerr != OFMT_SUCCESS) {
                char    e[80];

                ilbadm_err(gettext("ofmt_open failed: %s"),
                    ofmt_strerror(oh, oerr, e, sizeof (e)));
                return (ILBADM_LIBERR);
        }

        sta.ilbst_oh = oh;

        rc = i_do_show_stats(&sta);

        ofmt_close(oh);
        return (rc);
}