#include <stdio.h>

#include <ctype.h>

#include <locale.h>

#include <signal.h>

#include <stdarg.h>

#include <stdlib.h>

#include <fcntl.h>

#include <string.h>

#include <stropts.h>

#include <sys/stat.h>

#include <errno.h>

#include <strings.h>

#include <getopt.h>

#include <unistd.h>

#include <priv.h>

#include <termios.h>

#include <pwd.h>

#include <auth_attr.h>

#include <auth_list.h>

#include <libintl.h>

#include <libdevinfo.h>

#include <libdlpi.h>

#include <libdladm.h>

#include <libdllink.h>

#include <libdlstat.h>

#include <libdlaggr.h>

#include <libinetutil.h>

#include <bsm/adt.h>

#include <bsm/adt_event.h>

#include <stddef.h>

#include <ofmt.h>

typedef struct link_chain_s {

datalink_id_t lc_linkid;

boolean_t lc_visited;

dladm_stat_chain_t *lc_statchain[DLADM_STAT_NUM_STATS];

struct link_chain_s *lc_next;

} link_chain_t;

typedef void * (*stats2str_t)(const char *, void *,

char, boolean_t);

typedef struct show_state {

link_chain_t *ls_linkchain;

boolean_t ls_stattype[DLADM_STAT_NUM_STATS];

stats2str_t ls_stats2str[DLADM_STAT_NUM_STATS];

ofmt_handle_t ls_ofmt;

char ls_unit;

boolean_t ls_parsable;

} show_state_t;

typedef struct show_history_state_s {

boolean_t hs_plot;

boolean_t hs_parsable;

boolean_t hs_printheader;

boolean_t hs_first;

boolean_t hs_showall;

ofmt_handle_t hs_ofmt;

} show_history_state_t;

static ofmt_cb_t print_default_cb;

static void dlstat_ofmt_check(ofmt_status_t, boolean_t, ofmt_handle_t);

typedef void cmdfunc_t(int, char **, const char *);

static cmdfunc_t do_show, do_show_history, do_show_phys, do_show_link;

static cmdfunc_t do_show_aggr;

static void die(const char *, ...);

static void die_optdup(int);

static void die_opterr(int, int, const char *);

static void die_dlerr(dladm_status_t, const char *, ...);

static void warn(const char *, ...);

typedef struct cmd {

char *c_name;

cmdfunc_t *c_fn;

const char *c_usage;

} cmd_t;

static cmd_t cmds[] = {

{ "", do_show,

"dlstat [-r | -t] [-i <interval>] [link]\n"

" dlstat [-a | -A] [-i <interval>] [-p] [ -o field[,...]]\n"

" [-u R|K|M|G|T|P] [link]"},

{ "show-phys", do_show_phys,

"dlstat show-phys [-r | -t] [-i interval] [-a]\n"

" [-p] [ -o field[,...]] [-u R|K|M|G|T|P] "

"[link]"},

{ "show-link", do_show_link,

"dlstat show-link [-r [-F] | -t] [-i interval] [-a]\n"

" [-p] [ -o field[,...]] [-u R|K|M|G|T|P] "

"[link]\n"

" dlstat show-link -h [-a] [-d] [-F <format>]\n"

" [-s <DD/MM/YYYY,HH:MM:SS>] "

"[-e <DD/MM/YYYY,HH:MM:SS>]\n"

" -f <logfile> [<link>]" },

{ "show-aggr", do_show_aggr,

"dlstat show-aggr [-r | -t] [-i interval] [-p]\n"

" [ -o field[,...]] [-u R|K|M|G|T|P] "

" [link]" }

};

#define MAXSTATLEN 15

typedef struct total_fields_buf_s {

char t_linkname[MAXLINKNAMELEN];

char t_ipackets[MAXSTATLEN];

char t_rbytes[MAXSTATLEN];

char t_opackets[MAXSTATLEN];

char t_obytes[MAXSTATLEN];

} total_fields_buf_t;

static ofmt_field_t total_s_fields[] = {

{ "LINK", 15,

offsetof(total_fields_buf_t, t_linkname), print_default_cb},

{ "IPKTS", 8,

offsetof(total_fields_buf_t, t_ipackets), print_default_cb},

{ "RBYTES", 8,

offsetof(total_fields_buf_t, t_rbytes), print_default_cb},

{ "OPKTS", 8,

offsetof(total_fields_buf_t, t_opackets), print_default_cb},

{ "OBYTES", 8,

offsetof(total_fields_buf_t, t_obytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct ring_fields_buf_s {

char r_linkname[MAXLINKNAMELEN];

char r_type[MAXSTATLEN];

char r_id[MAXSTATLEN];

char r_index[MAXSTATLEN];

char r_packets[MAXSTATLEN];

char r_bytes[MAXSTATLEN];

} ring_fields_buf_t;

static ofmt_field_t ring_s_fields[] = {

{ "LINK", 15,

offsetof(ring_fields_buf_t, r_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(ring_fields_buf_t, r_type), print_default_cb},

{ "ID", 7,

offsetof(ring_fields_buf_t, r_id), print_default_cb},

{ "INDEX", 6,

offsetof(ring_fields_buf_t, r_index), print_default_cb},

{ "PKTS", 8,

offsetof(ring_fields_buf_t, r_packets), print_default_cb},

{ "BYTES", 8,

offsetof(ring_fields_buf_t, r_bytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct rx_ring_fields_buf_s {

char rr_linkname[MAXLINKNAMELEN];

char rr_type[MAXSTATLEN];

char rr_id[MAXSTATLEN];

char rr_index[MAXSTATLEN];

char rr_ipackets[MAXSTATLEN];

char rr_rbytes[MAXSTATLEN];

} rx_ring_fields_buf_t;

static ofmt_field_t rx_ring_s_fields[] = {

{ "LINK", 15,

offsetof(rx_ring_fields_buf_t, rr_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(rx_ring_fields_buf_t, rr_type), print_default_cb},

{ "ID", 7,

offsetof(rx_ring_fields_buf_t, rr_id), print_default_cb},

{ "INDEX", 6,

offsetof(rx_ring_fields_buf_t, rr_index), print_default_cb},

{ "IPKTS", 8,

offsetof(rx_ring_fields_buf_t, rr_ipackets), print_default_cb},

{ "RBYTES", 8,

offsetof(rx_ring_fields_buf_t, rr_rbytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct tx_ring_fields_buf_s {

char tr_linkname[MAXLINKNAMELEN];

char tr_type[MAXSTATLEN];

char tr_id[MAXSTATLEN];

char tr_index[MAXSTATLEN];

char tr_opackets[MAXSTATLEN];

char tr_obytes[MAXSTATLEN];

} tx_ring_fields_buf_t;

static ofmt_field_t tx_ring_s_fields[] = {

{ "LINK", 15,

offsetof(tx_ring_fields_buf_t, tr_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(tx_ring_fields_buf_t, tr_type), print_default_cb},

{ "ID", 7,

offsetof(tx_ring_fields_buf_t, tr_id), print_default_cb},

{ "INDEX", 6,

offsetof(tx_ring_fields_buf_t, tr_index), print_default_cb},

{ "OPKTS", 8,

offsetof(tx_ring_fields_buf_t, tr_opackets), print_default_cb},

{ "OBYTES", 8,

offsetof(tx_ring_fields_buf_t, tr_obytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct lane_fields_buf_s {

char l_linkname[MAXLINKNAMELEN];

char l_type[MAXSTATLEN];

char l_id[MAXSTATLEN];

char l_index[MAXSTATLEN];

char l_packets[MAXSTATLEN];

char l_bytes[MAXSTATLEN];

} lane_fields_buf_t;

static ofmt_field_t lane_s_fields[] = {

{ "LINK", 15,

offsetof(lane_fields_buf_t, l_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(lane_fields_buf_t, l_type), print_default_cb},

{ "ID", 7,

offsetof(lane_fields_buf_t, l_id), print_default_cb},

{ "INDEX", 6,

offsetof(lane_fields_buf_t, l_index), print_default_cb},

{ "PKTS", 8,

offsetof(lane_fields_buf_t, l_packets), print_default_cb},

{ "BYTES", 8,

offsetof(lane_fields_buf_t, l_bytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct rx_lane_fields_buf_s {

char rl_linkname[MAXLINKNAMELEN];

char rl_type[MAXSTATLEN];

char rl_id[MAXSTATLEN];

char rl_index[MAXSTATLEN];

char rl_ipackets[MAXSTATLEN];

char rl_rbytes[MAXSTATLEN];

char rl_intrs[MAXSTATLEN];

char rl_polls[MAXSTATLEN];

char rl_sdrops[MAXSTATLEN];

char rl_chl10[MAXSTATLEN];

char rl_ch10_50[MAXSTATLEN];

char rl_chg50[MAXSTATLEN];

} rx_lane_fields_buf_t;

static ofmt_field_t rx_lane_s_fields[] = {

{ "LINK", 10,

offsetof(rx_lane_fields_buf_t, rl_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(rx_lane_fields_buf_t, rl_type), print_default_cb},

{ "ID", 7,

offsetof(rx_lane_fields_buf_t, rl_id), print_default_cb},

{ "INDEX", 6,

offsetof(rx_lane_fields_buf_t, rl_index), print_default_cb},

{ "IPKTS", 8,

offsetof(rx_lane_fields_buf_t, rl_ipackets), print_default_cb},

{ "RBYTES", 8,

offsetof(rx_lane_fields_buf_t, rl_rbytes), print_default_cb},

{ "INTRS", 8,

offsetof(rx_lane_fields_buf_t, rl_intrs), print_default_cb},

{ "POLLS", 8,

offsetof(rx_lane_fields_buf_t, rl_polls), print_default_cb},

{ "SDROPS", 8,

offsetof(rx_lane_fields_buf_t, rl_sdrops), print_default_cb},

{ "CH<10", 8,

offsetof(rx_lane_fields_buf_t, rl_chl10), print_default_cb},

{ "CH10-50", 8,

offsetof(rx_lane_fields_buf_t, rl_ch10_50), print_default_cb},

{ "CH>50", 8,

offsetof(rx_lane_fields_buf_t, rl_chg50), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct rx_fanout_lane_fields_buf_s {

char rfl_linkname[MAXLINKNAMELEN];

char rfl_type[MAXSTATLEN];

char rfl_id[MAXSTATLEN];

char rfl_index[MAXSTATLEN];

char rfl_fout[MAXSTATLEN];

char rfl_ipackets[MAXSTATLEN];

char rfl_rbytes[MAXSTATLEN];

} rx_fanout_lane_fields_buf_t;

static ofmt_field_t rx_fanout_lane_s_fields[] = {

{ "LINK", 15,

offsetof(rx_fanout_lane_fields_buf_t, rfl_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(rx_fanout_lane_fields_buf_t, rfl_type), print_default_cb},

{ "ID", 7,

offsetof(rx_fanout_lane_fields_buf_t, rfl_id), print_default_cb},

{ "INDEX", 6,

offsetof(rx_fanout_lane_fields_buf_t, rfl_index), print_default_cb},

{ "FOUT", 6,

offsetof(rx_fanout_lane_fields_buf_t, rfl_fout), print_default_cb},

{ "IPKTS", 8,

offsetof(rx_fanout_lane_fields_buf_t, rfl_ipackets), print_default_cb},

{ "RBYTES", 8,

offsetof(rx_fanout_lane_fields_buf_t, rfl_rbytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct tx_lane_fields_buf_s {

char tl_linkname[MAXLINKNAMELEN];

char tl_index[MAXSTATLEN];

char tl_type[MAXSTATLEN];

char tl_id[MAXSTATLEN];

char tl_opackets[MAXSTATLEN];

char tl_obytes[MAXSTATLEN];

char tl_blockcnt[MAXSTATLEN];

char tl_unblockcnt[MAXSTATLEN];

char tl_sdrops[MAXSTATLEN];

} tx_lane_fields_buf_t;

static ofmt_field_t tx_lane_s_fields[] = {

{ "LINK", 15,

offsetof(tx_lane_fields_buf_t, tl_linkname), print_default_cb},

{ "TYPE", 5,

offsetof(tx_lane_fields_buf_t, tl_type), print_default_cb},

{ "ID", 7,

offsetof(tx_lane_fields_buf_t, tl_id), print_default_cb},

{ "INDEX", 6,

offsetof(tx_lane_fields_buf_t, tl_index), print_default_cb},

{ "OPKTS", 8,

offsetof(tx_lane_fields_buf_t, tl_opackets), print_default_cb},

{ "OBYTES", 8,

offsetof(tx_lane_fields_buf_t, tl_obytes), print_default_cb},

{ "BLKCNT", 8,

offsetof(tx_lane_fields_buf_t, tl_blockcnt), print_default_cb},

{ "UBLKCNT", 8,

offsetof(tx_lane_fields_buf_t, tl_unblockcnt), print_default_cb},

{ "SDROPS", 8,

offsetof(tx_lane_fields_buf_t, tl_sdrops), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct aggr_port_fields_buf_s {

char ap_linkname[MAXLINKNAMELEN];

char ap_portname[MAXLINKNAMELEN];

char ap_ipackets[MAXSTATLEN];

char ap_rbytes[MAXSTATLEN];

char ap_opackets[MAXSTATLEN];

char ap_obytes[MAXSTATLEN];

} aggr_port_fields_buf_t;

static ofmt_field_t aggr_port_s_fields[] = {

{ "LINK", 15,

offsetof(aggr_port_fields_buf_t, ap_linkname), print_default_cb},

{ "PORT", 15,

offsetof(aggr_port_fields_buf_t, ap_portname), print_default_cb},

{ "IPKTS", 8,

offsetof(aggr_port_fields_buf_t, ap_ipackets), print_default_cb},

{ "RBYTES", 8,

offsetof(aggr_port_fields_buf_t, ap_rbytes), print_default_cb},

{ "OPKTS", 8,

offsetof(aggr_port_fields_buf_t, ap_opackets), print_default_cb},

{ "OBYTES", 8,

offsetof(aggr_port_fields_buf_t, ap_obytes), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct history_fields_buf_s {

char h_link[12];

char h_duration[10];

char h_ipackets[9];

char h_rbytes[10];

char h_opackets[9];

char h_obytes[10];

char h_bandwidth[14];

} history_fields_buf_t;

static ofmt_field_t history_fields[] = {

{ "LINK", 13,

offsetof(history_fields_buf_t, h_link), print_default_cb},

{ "DURATION", 11,

offsetof(history_fields_buf_t, h_duration), print_default_cb},

{ "IPKTS", 10,

offsetof(history_fields_buf_t, h_ipackets), print_default_cb},

{ "RBYTES", 11,

offsetof(history_fields_buf_t, h_rbytes), print_default_cb},

{ "OPKTS", 10,

offsetof(history_fields_buf_t, h_opackets), print_default_cb},

{ "OBYTES", 11,

offsetof(history_fields_buf_t, h_obytes), print_default_cb},

{ "BANDWIDTH", 15,

offsetof(history_fields_buf_t, h_bandwidth), print_default_cb},

{ NULL, 0, 0, NULL}};

typedef struct history_l_fields_buf_s {

char hl_link[12];

char hl_stime[13];

char hl_etime[13];

char hl_rbytes[8];

char hl_obytes[8];

char hl_bandwidth[14];

} history_l_fields_buf_t;

static ofmt_field_t history_l_fields[] = {

{ "LINK", 13,

offsetof(history_l_fields_buf_t, hl_link), print_default_cb},

{ "START", 14,

offsetof(history_l_fields_buf_t, hl_stime), print_default_cb},

{ "END", 14,

offsetof(history_l_fields_buf_t, hl_etime), print_default_cb},

{ "RBYTES", 9,

offsetof(history_l_fields_buf_t, hl_rbytes), print_default_cb},

{ "OBYTES", 9,

offsetof(history_l_fields_buf_t, hl_obytes), print_default_cb},

{ "BANDWIDTH", 15,

offsetof(history_l_fields_buf_t, hl_bandwidth), print_default_cb},

{ NULL, 0, 0, NULL}}

;

static char *progname;

static dladm_handle_t handle = NULL;

static void

usage(void)

{

int i;

cmd_t *cmdp;

(void) fprintf(stderr, gettext("usage: "));

for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {

cmdp = &cmds[i];

if (cmdp->c_usage != NULL)

(void) fprintf(stderr, "%s\n", gettext(cmdp->c_usage));

}

/* close dladm handle if it was opened */

if (handle != NULL)

dladm_close(handle);

exit(1);

}

main(int argc, char *argv[])

{

int i;

cmd_t *cmdp;

dladm_status_t status;

(void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)

#define TEXT_DOMAIN "SYS_TEST"

#endif

(void) textdomain(TEXT_DOMAIN);

progname = argv[0];

/* Open the libdladm handle */

if ((status = dladm_open(&handle)) != DLADM_STATUS_OK)

die_dlerr(status, "could not open /dev/dld");

if (argc == 1) {

do_show(argc - 1, NULL, cmds[0].c_usage);

goto done;

}

for (i = 0; i < sizeof (cmds) / sizeof (cmds[0]); i++) {

cmdp = &cmds[i];

if (strcmp(argv[1], cmdp->c_name) == 0) {

cmdp->c_fn(argc - 1, &argv[1], cmdp->c_usage);

goto done;

}

}

do_show(argc, &argv[0], cmds[0].c_usage);

done:

dladm_close(handle);

return (0);

}

static int

show_history_date(dladm_usage_t *history, void *arg)

{

show_history_state_t *state = arg;

time_t stime;

char timebuf[20];

dladm_status_t status;

uint32_t flags;

/*

if (!state->hs_showall) {

if ((status = dladm_name2info(handle, history->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

stime = history->du_stime;

(void) strftime(timebuf, sizeof (timebuf), "%m/%d/%Y",

localtime(&stime));

(void) printf("%s\n", timebuf);

return (DLADM_STATUS_OK);

}

static int

show_history_time(dladm_usage_t *history, void *arg)

{

show_history_state_t *state = arg;

char buf[DLADM_STRSIZE];

history_l_fields_buf_t ubuf;

time_t time;

double bw;

dladm_status_t status;

uint32_t flags;

/*

if (!state->hs_showall) {

if ((status = dladm_name2info(handle, history->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

if (state->hs_plot) {

if (!state->hs_printheader) {

if (state->hs_first) {

(void) printf("# Time");

state->hs_first = B_FALSE;

}

(void) printf(" %s", history->du_name);

if (history->du_last) {

(void) printf("\n");

state->hs_first = B_TRUE;

state->hs_printheader = B_TRUE;

}

} else {

if (state->hs_first) {

time = history->du_etime;

(void) strftime(buf, sizeof (buf), "%T",

localtime(&time));

state->hs_first = B_FALSE;

(void) printf("%s", buf);

}

bw = (double)history->du_bandwidth/1000;

(void) printf(" %.2f", bw);

if (history->du_last) {

(void) printf("\n");

state->hs_first = B_TRUE;

}

}

return (DLADM_STATUS_OK);

}

bzero(&ubuf, sizeof (ubuf));

(void) snprintf(ubuf.hl_link, sizeof (ubuf.hl_link), "%s",

history->du_name);

time = history->du_stime;

(void) strftime(buf, sizeof (buf), "%T", localtime(&time));

(void) snprintf(ubuf.hl_stime, sizeof (ubuf.hl_stime), "%s",

buf);

time = history->du_etime;

(void) strftime(buf, sizeof (buf), "%T", localtime(&time));

(void) snprintf(ubuf.hl_etime, sizeof (ubuf.hl_etime), "%s",

buf);

(void) snprintf(ubuf.hl_rbytes, sizeof (ubuf.hl_rbytes),

"%llu", history->du_rbytes);

(void) snprintf(ubuf.hl_obytes, sizeof (ubuf.hl_obytes),

"%llu", history->du_obytes);

(void) snprintf(ubuf.hl_bandwidth, sizeof (ubuf.hl_bandwidth),

"%s Mbps", dladm_bw2str(history->du_bandwidth, buf));

ofmt_print(state->hs_ofmt, &ubuf);

return (DLADM_STATUS_OK);

}

static int

show_history_res(dladm_usage_t *history, void *arg)

{

show_history_state_t *state = arg;

char buf[DLADM_STRSIZE];

history_fields_buf_t ubuf;

dladm_status_t status;

uint32_t flags;

/*

if (!state->hs_showall) {

if ((status = dladm_name2info(handle, history->du_name,

NULL, &flags, NULL, NULL)) != DLADM_STATUS_OK) {

return (status);

}

if ((flags & DLADM_OPT_ACTIVE) == 0)

return (DLADM_STATUS_LINKINVAL);

}

bzero(&ubuf, sizeof (ubuf));

(void) snprintf(ubuf.h_link, sizeof (ubuf.h_link), "%s",

history->du_name);

(void) snprintf(ubuf.h_duration, sizeof (ubuf.h_duration),

"%llu", history->du_duration);

(void) snprintf(ubuf.h_ipackets, sizeof (ubuf.h_ipackets),

"%llu", history->du_ipackets);

(void) snprintf(ubuf.h_rbytes, sizeof (ubuf.h_rbytes),

"%llu", history->du_rbytes);

(void) snprintf(ubuf.h_opackets, sizeof (ubuf.h_opackets),

"%llu", history->du_opackets);

(void) snprintf(ubuf.h_obytes, sizeof (ubuf.h_obytes),

"%llu", history->du_obytes);

(void) snprintf(ubuf.h_bandwidth, sizeof (ubuf.h_bandwidth),

"%s Mbps", dladm_bw2str(history->du_bandwidth, buf));

ofmt_print(state->hs_ofmt, &ubuf);

return (DLADM_STATUS_OK);

}

static boolean_t

valid_formatspec(char *formatspec_str)

{

return (strcmp(formatspec_str, "gnuplot") == 0);

}

static void

do_show_history(int argc, char *argv[], const char *use)

{

char *file = NULL;

int opt;

dladm_status_t status;

boolean_t d_arg = B_FALSE;

char *stime = NULL;

char *etime = NULL;

char *resource = NULL;

show_history_state_t state;

boolean_t o_arg = B_FALSE;

boolean_t F_arg = B_FALSE;

char *fields_str = NULL;

char *formatspec_str = NULL;

char *all_l_fields =

"link,start,end,rbytes,obytes,bandwidth";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = 0;

bzero(&state, sizeof (show_history_state_t));

state.hs_parsable = B_FALSE;

state.hs_printheader = B_FALSE;

state.hs_plot = B_FALSE;

state.hs_first = B_TRUE;

while ((opt = getopt(argc, argv, "das:e:o:f:F:")) != -1) {

switch (opt) {

case 'd':

d_arg = B_TRUE;

break;

case 'a':

state.hs_showall = B_TRUE;

break;

case 'f':

file = optarg;

break;

case 's':

stime = optarg;

break;

case 'e':

etime = optarg;

break;

case 'o':

o_arg = B_TRUE;

fields_str = optarg;

break;

case 'F':

state.hs_plot = F_arg = B_TRUE;

formatspec_str = optarg;

break;

default:

die_opterr(optopt, opt, use);

break;

}

}

if (file == NULL)

die("show-link -h requires a file");

if (optind == (argc-1)) {

uint32_t flags;

resource = argv[optind];

if (!state.hs_showall &&

(((status = dladm_name2info(handle, resource, NULL, &flags,

NULL, NULL)) != DLADM_STATUS_OK) ||

((flags & DLADM_OPT_ACTIVE) == 0))) {

die("invalid link: '%s'", resource);

}

}

if (F_arg && d_arg)

die("incompatible -d and -F options");

if (F_arg && !valid_formatspec(formatspec_str))

die("Format specifier %s not supported", formatspec_str);

if (state.hs_parsable)

ofmtflags |= OFMT_PARSABLE;

if (resource == NULL && stime == NULL && etime == NULL) {

oferr = ofmt_open(fields_str, history_fields, ofmtflags, 0,

&ofmt);

} else {

if (!o_arg || (o_arg && strcasecmp(fields_str, "all") == 0))

fields_str = all_l_fields;

oferr = ofmt_open(fields_str, history_l_fields, ofmtflags, 0,

&ofmt);

}

dlstat_ofmt_check(oferr, state.hs_parsable, ofmt);

state.hs_ofmt = ofmt;

if (d_arg) {

/* Print log dates */

status = dladm_usage_dates(show_history_date,

DLADM_LOGTYPE_LINK, file, resource, &state);

} else if (resource == NULL && stime == NULL && etime == NULL &&

!F_arg) {

/* Print summary */

status = dladm_usage_summary(show_history_res,

DLADM_LOGTYPE_LINK, file, &state);

} else if (resource != NULL) {

/* Print log entries for named resource */

status = dladm_walk_usage_res(show_history_time,

DLADM_LOGTYPE_LINK, file, resource, stime, etime, &state);

} else {

/* Print time and information for each link */

status = dladm_walk_usage_time(show_history_time,

DLADM_LOGTYPE_LINK, file, stime, etime, &state);

}

if (status != DLADM_STATUS_OK)

die_dlerr(status, "show-link -h");

ofmt_close(ofmt);

}

dlstat_unit(char *oarg, char *unit)

{

if ((strcmp(oarg, "R") == 0) || (strcmp(oarg, "K") == 0) ||

(strcmp(oarg, "M") == 0) || (strcmp(oarg, "G") == 0) ||

(strcmp(oarg, "T") == 0) || (strcmp(oarg, "P") == 0)) {

*unit = oarg[0];

return (B_TRUE);

}

return (B_FALSE);

}

map_to_units(char *buf, uint_t bufsize, double num, char unit,

boolean_t parsable)

{

if (parsable) {

(void) snprintf(buf, bufsize, "%.0lf", num);

return;

}

if (unit == '\0') {

int index;

for (index = 0; (int)(num/1000) != 0; index++, num /= 1000)

;

switch (index) {

case 0:

unit = '\0';

break;

case 1:

unit = 'K';

break;

case 2:

unit = 'M';

break;

case 3:

unit = 'G';

break;

case 4:

unit = 'T';

break;

case 5:

/* Largest unit supported */

default:

unit = 'P';

break;

}

} else {

switch (unit) {

case 'R':

/* Already raw numbers */

unit = '\0';

break;

case 'K':

num /= 1000;

break;

case 'M':

num /= (1000*1000);

break;

case 'G':

num /= (1000*1000*1000);

break;

case 'T':

num /= (1000.0*1000.0*1000.0*1000.0);

break;

case 'P':

/* Largest unit supported */

default:

num /= (1000.0*1000.0*1000.0*1000.0*1000.0);

break;

}

}

if (unit == '\0')

(void) snprintf(buf, bufsize, " %7.0lf%c", num, unit);

else

(void) snprintf(buf, bufsize, " %6.2lf%c", num, unit);

}

link_chain_t *

get_link_prev_stat(datalink_id_t linkid, void *arg)

{

show_state_t *state = (show_state_t *)arg;

link_chain_t *link_curr = NULL;

/* Scan prev linkid list and look for entry matching this entry */

for (link_curr = state->ls_linkchain; link_curr;

link_curr = link_curr->lc_next) {

if (link_curr->lc_linkid == linkid)

break;

}

/* New link, add it */

if (link_curr == NULL) {

link_curr = (link_chain_t *)malloc(sizeof (link_chain_t));

if (link_curr == NULL)

goto done;

link_curr->lc_linkid = linkid;

bzero(&link_curr->lc_statchain,

sizeof (link_curr->lc_statchain));

link_curr->lc_next = state->ls_linkchain;

state->ls_linkchain = link_curr;

}

done:

return (link_curr);

}

static void

cleanup_removed_links(show_state_t *state)

{

link_chain_t *lcurr;

link_chain_t *lprev;

link_chain_t *tofree;

int i;

/* Delete all nodes from the list that have lc_visited marked false */

lcurr = state->ls_linkchain;

while (lcurr != NULL) {

if (lcurr->lc_visited) {

lcurr->lc_visited = B_FALSE;

lprev = lcurr;

lcurr = lcurr->lc_next;

continue;

}

/* Is it head of the list? */

if (lcurr == state->ls_linkchain)

state->ls_linkchain = lcurr->lc_next;

else

lprev->lc_next = lcurr->lc_next;

/* lprev remains the same */

tofree = lcurr;

lcurr = lcurr->lc_next;

/* Free stats memory for the removed link */

for (i = 0; i < DLADM_STAT_NUM_STATS; i++) {

if (state->ls_stattype[i])

dladm_link_stat_free(tofree->lc_statchain[i]);

}

free(tofree);

}

}

void *

print_total_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

total_stat_entry_t *sentry = statentry;

total_stat_t *link_stats = &sentry->tse_stats;

total_fields_buf_t *buf;

buf = malloc(sizeof (total_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->t_linkname, sizeof (buf->t_linkname), "%s",

linkname);

map_to_units(buf->t_ipackets, sizeof (buf->t_ipackets),

link_stats->ts_ipackets, unit, parsable);

map_to_units(buf->t_rbytes, sizeof (buf->t_rbytes),

link_stats->ts_rbytes, unit, parsable);

map_to_units(buf->t_opackets, sizeof (buf->t_opackets),

link_stats->ts_opackets, unit, parsable);

map_to_units(buf->t_obytes, sizeof (buf->t_obytes),

link_stats->ts_obytes, unit, parsable);

done:

return (buf);

}

void *

print_rx_generic_ring_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

ring_stat_entry_t *sentry = statentry;

ring_stat_t *link_stats = &sentry->re_stats;

ring_fields_buf_t *buf;

buf = malloc(sizeof (ring_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->r_linkname, sizeof (buf->r_linkname), "%s",

linkname);

(void) snprintf(buf->r_type, sizeof (buf->r_type), "rx");

if (sentry->re_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->r_index, sizeof (buf->r_index), "--");

} else {

(void) snprintf(buf->r_index, sizeof (buf->r_index),

"%llu", sentry->re_index);

}

map_to_units(buf->r_packets, sizeof (buf->r_packets),

link_stats->r_packets, unit, parsable);

map_to_units(buf->r_bytes, sizeof (buf->r_bytes),

link_stats->r_bytes, unit, parsable);

done:

return (buf);

}

void *

print_tx_generic_ring_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

ring_stat_entry_t *sentry = statentry;

ring_stat_t *link_stats = &sentry->re_stats;

ring_fields_buf_t *buf;

buf = malloc(sizeof (ring_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->r_linkname, sizeof (buf->r_linkname), "%s",

linkname);

(void) snprintf(buf->r_type, sizeof (buf->r_type), "tx");

if (sentry->re_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->r_index, sizeof (buf->r_index), "--");

} else {

(void) snprintf(buf->r_index, sizeof (buf->r_index),

"%llu", sentry->re_index);

}

map_to_units(buf->r_packets, sizeof (buf->r_packets),

link_stats->r_packets, unit, parsable);

map_to_units(buf->r_bytes, sizeof (buf->r_bytes),

link_stats->r_bytes, unit, parsable);

done:

return (buf);

}

void *

print_rx_ring_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

ring_stat_entry_t *sentry = statentry;

ring_stat_t *link_stats = &sentry->re_stats;

rx_ring_fields_buf_t *buf;

buf = malloc(sizeof (rx_ring_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->rr_linkname, sizeof (buf->rr_linkname), "%s",

linkname);

(void) snprintf(buf->rr_type, sizeof (buf->rr_type), "rx");

if (sentry->re_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->rr_index, sizeof (buf->rr_index), "--");

} else {

(void) snprintf(buf->rr_index, sizeof (buf->rr_index),

"%llu", sentry->re_index);

}

map_to_units(buf->rr_ipackets, sizeof (buf->rr_ipackets),

link_stats->r_packets, unit, parsable);

map_to_units(buf->rr_rbytes, sizeof (buf->rr_rbytes),

link_stats->r_bytes, unit, parsable);

done:

return (buf);

}

void *

print_tx_ring_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

ring_stat_entry_t *sentry = statentry;

ring_stat_t *link_stats = &sentry->re_stats;

tx_ring_fields_buf_t *buf;

buf = malloc(sizeof (tx_ring_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->tr_linkname, sizeof (buf->tr_linkname), "%s",

linkname);

(void) snprintf(buf->tr_type, sizeof (buf->tr_type), "tx");

if (sentry->re_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->tr_index, sizeof (buf->tr_index), "--");

} else {

(void) snprintf(buf->tr_index, sizeof (buf->tr_index),

"%llu", sentry->re_index);

}

map_to_units(buf->tr_opackets, sizeof (buf->tr_opackets),

link_stats->r_packets, unit, parsable);

map_to_units(buf->tr_obytes, sizeof (buf->tr_obytes),

link_stats->r_bytes, unit, parsable);

done:

return (buf);

}

void *

print_rx_generic_lane_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

rx_lane_stat_entry_t *sentry = statentry;

rx_lane_stat_t *link_stats = &sentry->rle_stats;

lane_fields_buf_t *buf;

if (sentry->rle_id == L_DFNCT)

return (NULL);

buf = malloc(sizeof (lane_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->l_linkname, sizeof (buf->l_linkname), "%s",

linkname);

(void) snprintf(buf->l_type, sizeof (buf->l_type), "rx");

if (sentry->rle_id == L_HWLANE)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "hw");

else if (sentry->rle_id == L_SWLANE)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "sw");

else if (sentry->rle_id == L_LOCAL)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "local");

else if (sentry->rle_id == L_BCAST)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "bcast");

else

(void) snprintf(buf->l_id, sizeof (buf->l_id), "--");

if (sentry->rle_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->l_index, sizeof (buf->l_index), "--");

} else {

(void) snprintf(buf->l_index, sizeof (buf->l_index),

"%llu", sentry->rle_index);

}

map_to_units(buf->l_packets, sizeof (buf->l_packets),

link_stats->rl_ipackets, unit, parsable);

map_to_units(buf->l_bytes, sizeof (buf->l_bytes),

link_stats->rl_rbytes, unit, parsable);

done:

return (buf);

}

void *

print_tx_generic_lane_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

tx_lane_stat_entry_t *sentry = statentry;

tx_lane_stat_t *link_stats = &sentry->tle_stats;

lane_fields_buf_t *buf;

if (sentry->tle_id == L_DFNCT)

return (NULL);

buf = malloc(sizeof (lane_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->l_linkname, sizeof (buf->l_linkname), "%s",

linkname);

(void) snprintf(buf->l_type, sizeof (buf->l_type), "tx");

if (sentry->tle_id == L_HWLANE)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "hw");

else if (sentry->tle_id == L_SWLANE)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "sw");

else if (sentry->tle_id == L_BCAST)

(void) snprintf(buf->l_id, sizeof (buf->l_id), "bcast");

else

(void) snprintf(buf->l_id, sizeof (buf->l_id), "--");

if (sentry->tle_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->l_index, sizeof (buf->l_index), "--");

} else {

(void) snprintf(buf->l_index, sizeof (buf->l_index),

"%llu", sentry->tle_index);

}

map_to_units(buf->l_packets, sizeof (buf->l_packets),

link_stats->tl_opackets, unit, parsable);

map_to_units(buf->l_bytes, sizeof (buf->l_bytes),

link_stats->tl_obytes, unit, parsable);

done:

return (buf);

}

void *

print_rx_lane_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

rx_lane_stat_entry_t *sentry = statentry;

rx_lane_stat_t *link_stats = &sentry->rle_stats;

rx_lane_fields_buf_t *buf;

if (sentry->rle_id == L_DFNCT)

return (NULL);

buf = malloc(sizeof (rx_lane_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->rl_linkname, sizeof (buf->rl_linkname), "%s",

linkname);

(void) snprintf(buf->rl_type, sizeof (buf->rl_type), "rx");

if (sentry->rle_id == L_HWLANE)

(void) snprintf(buf->rl_id, sizeof (buf->rl_id), "hw");

else if (sentry->rle_id == L_SWLANE)

(void) snprintf(buf->rl_id, sizeof (buf->rl_id), "sw");

else if (sentry->rle_id == L_LOCAL)

(void) snprintf(buf->rl_id, sizeof (buf->rl_id), "local");

else if (sentry->rle_id == L_BCAST)

(void) snprintf(buf->rl_id, sizeof (buf->rl_id), "bcast");

else

(void) snprintf(buf->rl_id, sizeof (buf->rl_id), "--");

if (sentry->rle_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->rl_index, sizeof (buf->rl_index), "--");

} else {

(void) snprintf(buf->rl_index, sizeof (buf->rl_index),

"%llu", sentry->rle_index);

}

map_to_units(buf->rl_ipackets, sizeof (buf->rl_ipackets),

link_stats->rl_ipackets, unit, parsable);

map_to_units(buf->rl_rbytes, sizeof (buf->rl_rbytes),

link_stats->rl_rbytes, unit, parsable);

map_to_units(buf->rl_intrs, sizeof (buf->rl_intrs),

link_stats->rl_intrs, unit, parsable);

map_to_units(buf->rl_polls, sizeof (buf->rl_polls),

link_stats->rl_polls, unit, parsable);

map_to_units(buf->rl_sdrops, sizeof (buf->rl_sdrops),

link_stats->rl_sdrops, unit, parsable);

map_to_units(buf->rl_chl10, sizeof (buf->rl_chl10),

link_stats->rl_chl10, unit, parsable);

map_to_units(buf->rl_ch10_50, sizeof (buf->rl_ch10_50),

link_stats->rl_ch10_50, unit, parsable);

map_to_units(buf->rl_chg50, sizeof (buf->rl_chg50),

link_stats->rl_chg50, unit, parsable);

done:

return (buf);

}

void *

print_tx_lane_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

tx_lane_stat_entry_t *sentry = statentry;

tx_lane_stat_t *link_stats = &sentry->tle_stats;

tx_lane_fields_buf_t *buf = NULL;

if (sentry->tle_id == L_DFNCT)

return (NULL);

buf = malloc(sizeof (tx_lane_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->tl_linkname, sizeof (buf->tl_linkname), "%s",

linkname);

(void) snprintf(buf->tl_type, sizeof (buf->tl_type), "tx");

if (sentry->tle_id == L_HWLANE)

(void) snprintf(buf->tl_id, sizeof (buf->tl_id), "hw");

else if (sentry->tle_id == L_SWLANE)

(void) snprintf(buf->tl_id, sizeof (buf->tl_id), "sw");

else if (sentry->tle_id == L_BCAST)

(void) snprintf(buf->tl_id, sizeof (buf->tl_id), "bcast");

else

(void) snprintf(buf->tl_id, sizeof (buf->tl_id), "--");

if (sentry->tle_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->tl_index, sizeof (buf->tl_index), "--");

} else {

(void) snprintf(buf->tl_index, sizeof (buf->tl_index),

"%llu", sentry->tle_index);

}

map_to_units(buf->tl_opackets, sizeof (buf->tl_opackets),

link_stats->tl_opackets, unit, parsable);

map_to_units(buf->tl_obytes, sizeof (buf->tl_obytes),

link_stats->tl_obytes, unit, parsable);

map_to_units(buf->tl_blockcnt, sizeof (buf->tl_blockcnt),

link_stats->tl_blockcnt, unit, parsable);

map_to_units(buf->tl_unblockcnt, sizeof (buf->tl_unblockcnt),

link_stats->tl_unblockcnt, unit, parsable);

map_to_units(buf->tl_sdrops, sizeof (buf->tl_sdrops),

link_stats->tl_sdrops, unit, parsable);

done:

return (buf);

}

void *

print_fanout_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

fanout_stat_entry_t *sentry = statentry;

fanout_stat_t *link_stats = &sentry->fe_stats;

rx_fanout_lane_fields_buf_t *buf;

buf = malloc(sizeof (rx_fanout_lane_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->rfl_linkname, sizeof (buf->rfl_linkname), "%s",

linkname);

(void) snprintf(buf->rfl_type, sizeof (buf->rfl_type), "rx");

if (sentry->fe_id == L_HWLANE)

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "hw");

else if (sentry->fe_id == L_SWLANE)

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "sw");

else if (sentry->fe_id == L_LCLSWLANE)

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "lcl/sw");

else if (sentry->fe_id == L_LOCAL)

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "local");

else if (sentry->fe_id == L_BCAST)

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "bcast");

else

(void) snprintf(buf->rfl_id, sizeof (buf->rfl_id), "--");

if (sentry->fe_index == DLSTAT_INVALID_ENTRY) {

(void) snprintf(buf->rfl_index, sizeof (buf->rfl_index), "--");

} else {

(void) snprintf(buf->rfl_index, sizeof (buf->rfl_index),

"%llu", sentry->fe_index);

}

if (sentry->fe_foutindex == DLSTAT_INVALID_ENTRY)

(void) snprintf(buf->rfl_fout, sizeof (buf->rfl_fout), "--");

else {

(void) snprintf(buf->rfl_fout, sizeof (buf->rfl_fout), "%llu",

sentry->fe_foutindex);

}

map_to_units(buf->rfl_ipackets, sizeof (buf->rfl_ipackets),

link_stats->f_ipackets, unit, parsable);

map_to_units(buf->rfl_rbytes, sizeof (buf->rfl_rbytes),

link_stats->f_rbytes, unit, parsable);

done:

return (buf);

}

void *

print_aggr_port_stats(const char *linkname, void *statentry, char unit,

boolean_t parsable)

{

aggr_port_stat_entry_t *sentry = statentry;

aggr_port_stat_t *link_stats = &sentry->ape_stats;

aggr_port_fields_buf_t *buf;

char portname[MAXLINKNAMELEN];

buf = malloc(sizeof (aggr_port_fields_buf_t));

if (buf == NULL)

goto done;

(void) snprintf(buf->ap_linkname, sizeof (buf->ap_linkname), "%s",

linkname);

if (dladm_datalink_id2info(handle, sentry->ape_portlinkid, NULL,

NULL, NULL, portname, DLPI_LINKNAME_MAX)

!= DLADM_STATUS_OK) {

(void) snprintf(buf->ap_portname,

sizeof (buf->ap_portname), "--");

} else {

(void) snprintf(buf->ap_portname,

sizeof (buf->ap_portname), "%s", portname);

}

map_to_units(buf->ap_ipackets, sizeof (buf->ap_ipackets),

link_stats->ap_ipackets, unit, parsable);

map_to_units(buf->ap_rbytes, sizeof (buf->ap_rbytes),

link_stats->ap_rbytes, unit, parsable);

map_to_units(buf->ap_opackets, sizeof (buf->ap_opackets),

link_stats->ap_opackets, unit, parsable);

map_to_units(buf->ap_obytes, sizeof (buf->ap_obytes),

link_stats->ap_obytes, unit, parsable);

done:

return (buf);

}

dladm_stat_chain_t *

query_link_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg,

dladm_stat_type_t stattype)

{

link_chain_t *link_node;

dladm_stat_chain_t *curr_stat;

dladm_stat_chain_t *prev_stat = NULL;

dladm_stat_chain_t *diff_stat = NULL;

/* Get prev iteration stat for this link */

link_node = get_link_prev_stat(linkid, arg);

if (link_node == NULL)

goto done;

link_node->lc_visited = B_TRUE;

prev_stat = link_node->lc_statchain[stattype];

/* Query library for current stats */

curr_stat = dladm_link_stat_query(dh, linkid, stattype);

if (curr_stat == NULL)

goto done;

/* current stats - prev iteration stats */

diff_stat = dladm_link_stat_diffchain(curr_stat, prev_stat, stattype);

/* Free prev stats */

dladm_link_stat_free(prev_stat);

/* Prev <- curr stats */

link_node->lc_statchain[stattype] = curr_stat;

done:

return (diff_stat);

}

walk_dlstat_stats(show_state_t *state, const char *linkname,

dladm_stat_type_t stattype, dladm_stat_chain_t *diff_stat)

{

dladm_stat_chain_t *curr;

/* Unpack invidual stat entry and call library consumer's callback */

for (curr = diff_stat; curr != NULL; curr = curr->dc_next) {

void *fields_buf;

/* Format the raw numbers for printing */

fields_buf = state->ls_stats2str[stattype](linkname,

curr->dc_statentry, state->ls_unit, state->ls_parsable);

/* Print the stats */

if (fields_buf != NULL)

ofmt_print(state->ls_ofmt, fields_buf);

free(fields_buf);

}

}

static int

show_queried_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

show_state_t *state = arg;

int i;

dladm_stat_chain_t *diff_stat;

char linkname[DLPI_LINKNAME_MAX];

if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, linkname,

DLPI_LINKNAME_MAX) != DLADM_STATUS_OK) {

goto done;

}

for (i = 0; i < DLADM_STAT_NUM_STATS; i++) {

if (state->ls_stattype[i]) {

/*

diff_stat = query_link_stats(handle, linkid, arg, i);

walk_dlstat_stats(state, linkname, i, diff_stat);

dladm_link_stat_free(diff_stat);

}

}

done:

return (DLADM_WALK_CONTINUE);

}

show_link_stats(datalink_id_t linkid, show_state_t state, uint32_t interval)

{

for (;;) {

if (linkid == DATALINK_ALL_LINKID) {

(void) dladm_walk_datalink_id(show_queried_stats,

handle, &state, DATALINK_CLASS_ALL,

DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);

} else {

(void) show_queried_stats(handle, linkid, &state);

}

if (interval == 0)

break;

cleanup_removed_links(&state);

(void) sleep(interval);

}

}

print_all_stats(dladm_handle_t dh, datalink_id_t linkid,

dladm_stat_chain_t *stat_chain)

{

dladm_stat_chain_t *curr;

name_value_stat_entry_t *stat_entry;

name_value_stat_t *curr_stat;

boolean_t stat_printed = B_FALSE;

char linkname[MAXLINKNAMELEN];

char prev_linkname[MAXLINKNAMELEN];

if (dladm_datalink_id2info(dh, linkid, NULL, NULL, NULL, linkname,

DLPI_LINKNAME_MAX) != DLADM_STATUS_OK)

return;

for (curr = stat_chain; curr != NULL; curr = curr->dc_next) {

stat_entry = curr->dc_statentry;

/*

if (strcmp(prev_linkname, linkname) != 0)

printf("%s \n", linkname);

printf(" %s \n", stat_entry->nve_header);

/* Print stat fields */

for (curr_stat = stat_entry->nve_stats; curr_stat != NULL;

curr_stat = curr_stat->nv_nextstat) {

printf("\t%15s", curr_stat->nv_statname);

printf("\t\t%15llu\n", curr_stat->nv_statval);

}

strncpy(prev_linkname, linkname, MAXLINKNAMELEN);

stat_printed = B_TRUE;

}

if (stat_printed)

printf("---------------------------------------------------\n");

}

static int

dump_queried_stats(dladm_handle_t dh, datalink_id_t linkid, void *arg)

{

boolean_t *stattype = arg;

int i;

dladm_stat_chain_t *stat_chain;

for (i = 0; i < DLADM_STAT_NUM_STATS; i++) {

if (stattype[i]) {

stat_chain = dladm_link_stat_query_all(dh, linkid, i);

print_all_stats(dh, linkid, stat_chain);

dladm_link_stat_query_all_free(stat_chain);

}

}

done:

return (DLADM_WALK_CONTINUE);

}

dump_all_link_stats(datalink_id_t linkid, boolean_t *stattype)

{

if (linkid == DATALINK_ALL_LINKID) {

(void) dladm_walk_datalink_id(dump_queried_stats,

handle, stattype, DATALINK_CLASS_ALL,

DATALINK_ANY_MEDIATYPE, DLADM_OPT_ACTIVE);

} else {

(void) dump_queried_stats(handle, linkid, stattype);

}

}

static void

do_show(int argc, char *argv[], const char *use)

{

int option;

boolean_t r_arg = B_FALSE;

boolean_t t_arg = B_FALSE;

boolean_t i_arg = B_FALSE;

boolean_t p_arg = B_FALSE;

boolean_t o_arg = B_FALSE;

boolean_t u_arg = B_FALSE;

boolean_t a_arg = B_FALSE;

boolean_t A_arg = B_FALSE;

uint32_t flags = DLADM_OPT_ACTIVE;

datalink_id_t linkid = DATALINK_ALL_LINKID;

uint32_t interval = 0;

char unit = '\0';

show_state_t state;

dladm_status_t status;

char *fields_str = NULL;

char *o_fields_str = NULL;

char *total_stat_fields =

"link,ipkts,rbytes,opkts,obytes";

char *rx_total_stat_fields =

"link,ipkts,rbytes,intrs,polls,ch<10,ch10-50,ch>50";

char *tx_total_stat_fields =

"link,opkts,obytes,blkcnt,ublkcnt";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = OFMT_RIGHTJUST;

ofmt_field_t *oftemplate;

bzero(&state, sizeof (state));

opterr = 0;

while ((option = getopt_long(argc, argv, ":rtaApi:o:u:",

NULL, NULL)) != -1) {

switch (option) {

case 'r':

if (r_arg)

die_optdup(option);

r_arg = B_TRUE;

break;

case 't':

if (t_arg)

die_optdup(option);

t_arg = B_TRUE;

break;

case 'a':

if (a_arg)

die_optdup(option);

a_arg = B_TRUE;

break;

case 'A':

if (A_arg)

die_optdup(option);

A_arg = B_TRUE;

break;

case 'i':

if (i_arg)

die_optdup(option);

i_arg = B_TRUE;

if (!dladm_str2interval(optarg, &interval))

die("invalid interval value '%s'", optarg);

break;

case 'p':

if (p_arg)

die_optdup(option);

p_arg = B_TRUE;

break;

case 'o':

o_arg = B_TRUE;

o_fields_str = optarg;

break;

case 'u':

if (u_arg)

die_optdup(option);

u_arg = B_TRUE;

if (!dlstat_unit(optarg, &unit))

die("invalid unit value '%s',"

"unit must be R|K|M|G|T|P", optarg);

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (r_arg && t_arg)

die("the options -t and -r are not compatible");

if (u_arg && p_arg)

die("the options -u and -p are not compatible");

if (p_arg && !o_arg)

die("-p requires -o");

if (p_arg && strcasecmp(o_fields_str, "all") == 0)

die("\"-o all\" is invalid with -p");

if (a_arg && A_arg)

die("the options -a and -A are not compatible");

if (a_arg &&

(p_arg || o_arg || u_arg || i_arg)) {

die("the option -a is not compatible with "

"-p, -o, -u, -i");

}

if (A_arg &&

(r_arg || t_arg || p_arg || o_arg || u_arg || i_arg)) {

die("the option -A is not compatible with "

"-r, -t, -p, -o, -u, -i");

}

/* get link name (optional last argument) */

if (optind == (argc-1)) {

if (strlen(argv[optind]) >= MAXLINKNAMELEN)

die("link name too long");

if ((status = dladm_name2info(handle, argv[optind], &linkid,

NULL, NULL, NULL)) != DLADM_STATUS_OK) {

die_dlerr(status, "link %s is not valid", argv[optind]);

}

} else if (optind != argc) {

if (argc != 0)

usage();

}

if (a_arg) {

boolean_t stattype[DLADM_STAT_NUM_STATS];

bzero(&stattype, sizeof (stattype));

if (r_arg) {

stattype[DLADM_STAT_RX_LANE_TOTAL] = B_TRUE;

} else if (t_arg) {

stattype[DLADM_STAT_TX_LANE_TOTAL] = B_TRUE;

} else { /* Display both Rx and Tx lanes */

stattype[DLADM_STAT_TOTAL] = B_TRUE;

}

dump_all_link_stats(linkid, stattype);

return;

}

if (A_arg) {

boolean_t stattype[DLADM_STAT_NUM_STATS];

int i;

for (i = 0; i < DLADM_STAT_NUM_STATS; i++)

stattype[i] = B_TRUE;

dump_all_link_stats(linkid, stattype);

return;

}

state.ls_unit = unit;

state.ls_parsable = p_arg;

if (state.ls_parsable)

ofmtflags |= OFMT_PARSABLE;

if (r_arg) {

fields_str = rx_total_stat_fields;

oftemplate = rx_lane_s_fields;

state.ls_stattype[DLADM_STAT_RX_LANE_TOTAL] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_LANE_TOTAL] =

print_rx_lane_stats;

} else if (t_arg) {

fields_str = tx_total_stat_fields;

oftemplate = tx_lane_s_fields;

state.ls_stattype[DLADM_STAT_TX_LANE_TOTAL] = B_TRUE;

state.ls_stats2str[DLADM_STAT_TX_LANE_TOTAL] =

print_tx_lane_stats;

} else { /* Display both Rx and Tx lanes total */

fields_str = total_stat_fields;

oftemplate = total_s_fields;

state.ls_stattype[DLADM_STAT_TOTAL] = B_TRUE;

state.ls_stats2str[DLADM_STAT_TOTAL] = print_total_stats;

}

if (o_arg) {

fields_str = (strcasecmp(o_fields_str, "all") == 0) ?

fields_str : o_fields_str;

}

oferr = ofmt_open(fields_str, oftemplate, ofmtflags, 0, &ofmt);

dlstat_ofmt_check(oferr, state.ls_parsable, ofmt);

state.ls_ofmt = ofmt;

show_link_stats(linkid, state, interval);

ofmt_close(ofmt);

}

static void

do_show_phys(int argc, char *argv[], const char *use)

{

int option;

boolean_t r_arg = B_FALSE;

boolean_t t_arg = B_FALSE;

boolean_t i_arg = B_FALSE;

boolean_t p_arg = B_FALSE;

boolean_t o_arg = B_FALSE;

boolean_t u_arg = B_FALSE;

boolean_t a_arg = B_FALSE;

uint32_t flags = DLADM_OPT_ACTIVE;

datalink_id_t linkid = DATALINK_ALL_LINKID;

char linkname[MAXLINKNAMELEN];

uint32_t interval = 0;

char unit = '\0';

show_state_t state;

dladm_status_t status;

char *fields_str = NULL;

char *o_fields_str = NULL;

char *ring_stat_fields =

"link,type,index,pkts,bytes";

char *rx_ring_stat_fields =

"link,type,index,ipkts,rbytes";

char *tx_ring_stat_fields =

"link,type,index,opkts,obytes";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = OFMT_RIGHTJUST;

ofmt_field_t *oftemplate;

bzero(&state, sizeof (state));

opterr = 0;

while ((option = getopt_long(argc, argv, ":rtapi:o:u:",

NULL, NULL)) != -1) {

switch (option) {

case 'r':

if (r_arg)

die_optdup(option);

r_arg = B_TRUE;

break;

case 't':

if (t_arg)

die_optdup(option);

t_arg = B_TRUE;

break;

case 'a':

if (a_arg)

die_optdup(option);

a_arg = B_TRUE;

break;

case 'i':

if (i_arg)

die_optdup(option);

i_arg = B_TRUE;

if (!dladm_str2interval(optarg, &interval))

die("invalid interval value '%s'", optarg);

break;

case 'p':

if (p_arg)

die_optdup(option);

p_arg = B_TRUE;

break;

case 'o':

o_arg = B_TRUE;

o_fields_str = optarg;

break;

case 'u':

if (u_arg)

die_optdup(option);

u_arg = B_TRUE;

if (!dlstat_unit(optarg, &unit))

die("invalid unit value '%s',"

"unit must be R|K|M|G|T|P", optarg);

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (r_arg && t_arg)

die("the options -t and -r are not compatible");

if (u_arg && p_arg)

die("the options -u and -p are not compatible");

if (p_arg && !o_arg)

die("-p requires -o");

if (p_arg && strcasecmp(o_fields_str, "all") == 0)

die("\"-o all\" is invalid with -p");

if (a_arg &&

(p_arg || o_arg || u_arg || i_arg)) {

die("the option -a is not compatible with "

"-p, -o, -u, -i");

}

/* get link name (optional last argument) */

if (optind == (argc-1)) {

if (strlen(argv[optind]) >= MAXLINKNAMELEN)

die("link name too long");

if ((status = dladm_name2info(handle, argv[optind], &linkid,

NULL, NULL, NULL)) != DLADM_STATUS_OK) {

die_dlerr(status, "link %s is not valid", argv[optind]);

}

} else if (optind != argc) {

usage();

}

if (a_arg) {

boolean_t stattype[DLADM_STAT_NUM_STATS];

bzero(&stattype, sizeof (stattype));

if (r_arg) {

stattype[DLADM_STAT_RX_RING] = B_TRUE;

} else if (t_arg) {

stattype[DLADM_STAT_TX_RING] = B_TRUE;

} else { /* Display both Rx and Tx lanes */

stattype[DLADM_STAT_RX_RING] = B_TRUE;

stattype[DLADM_STAT_TX_RING] = B_TRUE;

}

dump_all_link_stats(linkid, stattype);

return;

}

state.ls_unit = unit;

state.ls_parsable = p_arg;

if (state.ls_parsable)

ofmtflags |= OFMT_PARSABLE;

if (r_arg) {

fields_str = rx_ring_stat_fields;

oftemplate = rx_ring_s_fields;

state.ls_stattype[DLADM_STAT_RX_RING] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_RING] = print_rx_ring_stats;

} else if (t_arg) {

fields_str = tx_ring_stat_fields;

oftemplate = tx_ring_s_fields;

state.ls_stattype[DLADM_STAT_TX_RING] = B_TRUE;

state.ls_stats2str[DLADM_STAT_TX_RING] = print_tx_ring_stats;

} else { /* Display both Rx and Tx lanes */

fields_str = ring_stat_fields;

oftemplate = ring_s_fields;

state.ls_stattype[DLADM_STAT_RX_RING] = B_TRUE;

state.ls_stattype[DLADM_STAT_TX_RING] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_RING] =

print_rx_generic_ring_stats;

state.ls_stats2str[DLADM_STAT_TX_RING] =

print_tx_generic_ring_stats;

}

if (o_arg) {

fields_str = (strcasecmp(o_fields_str, "all") == 0) ?

fields_str : o_fields_str;

}

oferr = ofmt_open(fields_str, oftemplate, ofmtflags, 0, &ofmt);

dlstat_ofmt_check(oferr, state.ls_parsable, ofmt);

state.ls_ofmt = ofmt;

show_link_stats(linkid, state, interval);

ofmt_close(ofmt);

}

static void

do_show_link(int argc, char *argv[], const char *use)

{

int option;

boolean_t r_arg = B_FALSE;

boolean_t F_arg = B_FALSE;

boolean_t t_arg = B_FALSE;

boolean_t i_arg = B_FALSE;

boolean_t p_arg = B_FALSE;

boolean_t o_arg = B_FALSE;

boolean_t u_arg = B_FALSE;

boolean_t a_arg = B_FALSE;

uint32_t flags = DLADM_OPT_ACTIVE;

datalink_id_t linkid = DATALINK_ALL_LINKID;

uint32_t interval = 0;

char unit = '\0';

show_state_t state;

dladm_status_t status;

char *fields_str = NULL;

char *o_fields_str = NULL;

char *lane_stat_fields =

"link,type,id,index,pkts,bytes";

char *rx_lane_stat_fields =

"link,type,id,index,ipkts,rbytes,intrs,polls,ch<10,ch10-50,ch>50";

char *tx_lane_stat_fields =

"link,type,id,index,opkts,obytes,blkcnt,ublkcnt";

char *rx_fanout_stat_fields =

"link,id,index,fout,ipkts,rbytes";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = OFMT_RIGHTJUST;

ofmt_field_t *oftemplate;

bzero(&state, sizeof (state));

opterr = 0;

while ((option = getopt_long(argc, argv, ":hrtFapi:o:u:",

NULL, NULL)) != -1) {

switch (option) {

case 'h':

if (r_arg || F_arg || t_arg || i_arg || p_arg ||

o_arg || u_arg || a_arg) {

die("the option -h is not compatible with "

"-r, -F, -t, -i, -p, -o, -u, -a");

}

do_show_history(argc, &argv[0], use);

return;

case 'r':

if (r_arg)

die_optdup(option);

r_arg = B_TRUE;

break;

case 'F':

if (F_arg)

die_optdup(option);

F_arg = B_TRUE;

break;

case 't':

if (t_arg)

die_optdup(option);

t_arg = B_TRUE;

break;

case 'a':

if (a_arg)

die_optdup(option);

a_arg = B_TRUE;

break;

case 'i':

if (i_arg)

die_optdup(option);

i_arg = B_TRUE;

if (!dladm_str2interval(optarg, &interval))

die("invalid interval value '%s'", optarg);

break;

case 'p':

if (p_arg)

die_optdup(option);

p_arg = B_TRUE;

break;

case 'o':

o_arg = B_TRUE;

o_fields_str = optarg;

break;

case 'u':

if (u_arg)

die_optdup(option);

u_arg = B_TRUE;

if (!dlstat_unit(optarg, &unit))

die("invalid unit value '%s',"

"unit must be R|K|M|G|T|P", optarg);

break;

default:

die_opterr(optopt, option, use);

break;

}

}

if (r_arg && t_arg)

die("the options -t and -r are not compatible");

if (u_arg && p_arg)

die("the options -u and -p are not compatible");

if (F_arg && !r_arg)

die("-F must be used with -r");

if (p_arg && !o_arg)

die("-p requires -o");

if (p_arg && strcasecmp(o_fields_str, "all") == 0)

die("\"-o all\" is invalid with -p");

if (a_arg &&

(p_arg || o_arg || u_arg || i_arg)) {

die("the option -a is not compatible with "

"-p, -o, -u, -i");

}

/* get link name (optional last argument) */

if (optind == (argc-1)) {

if (strlen(argv[optind]) >= MAXLINKNAMELEN)

die("link name too long");

if ((status = dladm_name2info(handle, argv[optind], &linkid,

NULL, NULL, NULL)) != DLADM_STATUS_OK) {

die_dlerr(status, "link %s is not valid", argv[optind]);

}

} else if (optind != argc) {

usage();

}

if (a_arg) {

boolean_t stattype[DLADM_STAT_NUM_STATS];

bzero(&stattype, sizeof (stattype));

if (r_arg) {

if (F_arg) {

stattype[DLADM_STAT_RX_LANE_FOUT] = B_TRUE;

} else {

stattype[DLADM_STAT_RX_LANE] = B_TRUE;

}

} else if (t_arg) {

stattype[DLADM_STAT_TX_LANE] = B_TRUE;

} else { /* Display both Rx and Tx lanes */

stattype[DLADM_STAT_RX_LANE] = B_TRUE;

stattype[DLADM_STAT_TX_LANE] = B_TRUE;

}

dump_all_link_stats(linkid, stattype);

return;

}

state.ls_unit = unit;

state.ls_parsable = p_arg;

if (state.ls_parsable)

ofmtflags |= OFMT_PARSABLE;

if (r_arg) {

if (F_arg) {

fields_str = rx_fanout_stat_fields;

oftemplate = rx_fanout_lane_s_fields;

state.ls_stattype[DLADM_STAT_RX_LANE_FOUT] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_LANE_FOUT] =

print_fanout_stats;

} else {

fields_str = rx_lane_stat_fields;

oftemplate = rx_lane_s_fields;

state.ls_stattype[DLADM_STAT_RX_LANE] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_LANE] =

print_rx_lane_stats;

}

} else if (t_arg) {

fields_str = tx_lane_stat_fields;

oftemplate = tx_lane_s_fields;

state.ls_stattype[DLADM_STAT_TX_LANE] = B_TRUE;

state.ls_stats2str[DLADM_STAT_TX_LANE] = print_tx_lane_stats;

} else { /* Display both Rx and Tx lanes */

fields_str = lane_stat_fields;

oftemplate = lane_s_fields;

state.ls_stattype[DLADM_STAT_RX_LANE] = B_TRUE;

state.ls_stattype[DLADM_STAT_TX_LANE] = B_TRUE;

state.ls_stats2str[DLADM_STAT_RX_LANE] =

print_rx_generic_lane_stats;

state.ls_stats2str[DLADM_STAT_TX_LANE] =

print_tx_generic_lane_stats;

}

if (o_arg) {

fields_str = (strcasecmp(o_fields_str, "all") == 0) ?

fields_str : o_fields_str;

}

oferr = ofmt_open(fields_str, oftemplate, ofmtflags, 0, &ofmt);

dlstat_ofmt_check(oferr, state.ls_parsable, ofmt);

state.ls_ofmt = ofmt;

show_link_stats(linkid, state, interval);

ofmt_close(ofmt);

}

static void

do_show_aggr(int argc, char *argv[], const char *use)

{

int option;

boolean_t r_arg = B_FALSE;

boolean_t t_arg = B_FALSE;

boolean_t i_arg = B_FALSE;

boolean_t p_arg = B_FALSE;

boolean_t o_arg = B_FALSE;

boolean_t u_arg = B_FALSE;

uint32_t flags = DLADM_OPT_ACTIVE;

datalink_id_t linkid = DATALINK_ALL_LINKID;

uint32_t interval = 0;

char unit = '\0';

show_state_t state;

dladm_status_t status;

char *fields_str = NULL;

char *o_fields_str = NULL;

char *aggr_stat_fields =

"link,port,ipkts,rbytes,opkts,obytes";

char *rx_aggr_stat_fields = "link,port,ipkts,rbytes";

char *tx_aggr_stat_fields = "link,port,opkts,obytes";

ofmt_handle_t ofmt;

ofmt_status_t oferr;

uint_t ofmtflags = OFMT_RIGHTJUST;

ofmt_field_t *oftemplate;

bzero(&state, sizeof (state));

opterr = 0;

while ((option = getopt_long(argc, argv, ":rtpi:o:u:",

NULL, NULL)) != -1) {

switch (option) {

case 'r':

if (r_arg)

die_optdup(option);

r_arg = B_TRUE;

break;

case 't':

if (t_arg)

die_optdup(option);

t_arg = B_TRUE;

break;

case 'i':

if (i_arg)

die_optdup(option);

i_arg = B_TRUE;

if (!dladm_str2interval(optarg, &interval))