OpenSolaris_b135/lib/libdladm/common/usage.c
/*
* 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.
*/
#include <fcntl.h>
#include <stdlib.h>
#include <strings.h>
#include <exacct.h>
#include <net/if.h>
#include <sys/ethernet.h>
#include <libdladm.h>
#define TIMEBUFLEN 20
#define GBIT 1000000000
#define MBIT 1000000
#define KBIT 1000
#define NET_RESET_TOT(tbytes, ttime, tibytes, tobytes, step) { \
(step) = 1; \
(tbytes) = 0; \
(ttime) = 0; \
(tibytes) = 0; \
(tobytes) = 0; \
}
/* Flow/Link Descriptor */
typedef struct net_desc_s {
char net_desc_name[LIFNAMSIZ];
char net_desc_devname[LIFNAMSIZ];
uchar_t net_desc_ehost[ETHERADDRL];
uchar_t net_desc_edest[ETHERADDRL];
ushort_t net_desc_vlan_tpid;
ushort_t net_desc_vlan_tci;
ushort_t net_desc_sap;
ushort_t net_desc_cpuid;
ushort_t net_desc_priority;
uint64_t net_desc_bw_limit;
in6_addr_t net_desc_saddr;
in6_addr_t net_desc_daddr;
boolean_t net_desc_isv4;
in_port_t net_desc_sport;
in_port_t net_desc_dport;
uint8_t net_desc_protocol;
uint8_t net_desc_dsfield;
boolean_t net_desc_newrec;
} net_desc_t;
/* Time structure: Year, Month, Day, Hour, Min, Sec */
typedef struct net_time_s {
int net_time_yr;
int net_time_mon;
int net_time_day;
int net_time_hr;
int net_time_min;
int net_time_sec;
} net_time_t;
/* Flow/Link Stats */
typedef struct net_stat_s {
char net_stat_name[LIFNAMSIZ];
uint64_t net_stat_ibytes;
uint64_t net_stat_obytes;
uint64_t net_stat_ipackets;
uint64_t net_stat_opackets;
uint64_t net_stat_ierrors;
uint64_t net_stat_oerrors;
uint64_t net_stat_tibytes;
uint64_t net_stat_tobytes;
uint64_t net_stat_tipackets;
uint64_t net_stat_topackets;
uint64_t net_stat_tierrors;
uint64_t net_stat_toerrors;
uint64_t net_stat_ctime;
uint64_t net_stat_tdiff;
net_time_t net_stat_time;
struct net_stat_s *net_stat_next;
net_desc_t *net_stat_desc;
boolean_t net_stat_isref;
} net_stat_t;
/* Used to create the [gnu]plot file */
typedef struct net_plot_entry_s {
char *net_pe_name;
uint64_t net_pe_tottime;
uint64_t net_pe_totbytes;
uint64_t net_pe_totibytes;
uint64_t net_pe_totobytes;
uint64_t net_pe_lasttime;
} net_plot_entry_t;
/* Stats entry */
typedef struct net_entry_s {
net_desc_t *net_entry_desc;
net_stat_t *net_entry_shead;
net_stat_t *net_entry_stail;
int net_entry_scount;
net_stat_t *net_entry_sref;
net_stat_t *net_entry_tstats;
uint64_t net_entry_ttime;
struct net_entry_s *net_entry_next;
} net_entry_t;
/* Time sorted list */
typedef struct net_time_entry_s {
net_stat_t *my_time_stat;
struct net_time_entry_s *net_time_entry_next;
struct net_time_entry_s *net_time_entry_prev;
} net_time_entry_t;
/* The parsed table */
typedef struct net_table_s {
/* List of stats */
net_entry_t *net_table_head;
net_entry_t *net_table_tail;
int net_entries;
/*
* Optimization I : List sorted by time, i.e:
* Time Resource ..
* -------------------------------
* 11.15.10 bge0
* 11.15.10 ce0
* 11.15.10 vnic1
* 11.15.15 bge0
* 11.15.15 ce0
* 11.15.15 vnic1
*/
net_time_entry_t *net_time_head;
net_time_entry_t *net_time_tail;
/*
* Optimization II : List sorted by resources
* Time Resource ..
* -------------------------------
* 11.15.10 bge0
* 11.15.15 bge0
* 11.15.10 ce0
* 11.15.15 ce0
* 11.15.10 vnic1
* 11.15.15 vnic1
*/
net_time_entry_t *net_ctime_head;
net_time_entry_t *net_ctime_tail;
/* Common to both the above (sorted) lists. */
int net_time_entries;
} net_table_t;
#define NET_DATE_GREATER 0
#define NET_DATE_LESSER 1
#define NET_DATE_EQUAL 2
#define NET_TIME_GREATER 0
#define NET_TIME_LESSER 1
#define NET_TIME_EQUAL 2
#ifndef _LP64
#define FMT_UINT64 "%-15llu"
#else
#define FMT_UINT64 "%-15lu"
#endif
/*
* Given a timebuf of the form M/D/Y,H:M:S break it into individual elements.
*/
static void
dissect_time(char *tbuf, net_time_t *nt)
{
char *d;
char *t;
char *dd;
char *h;
char *endp;
if (tbuf == NULL || nt == NULL)
return;
d = strtok(tbuf, ","); /* Date */
t = strtok(NULL, ","); /* Time */
/* Month */
dd = strtok(d, "/");
if (dd == NULL)
return;
nt->net_time_mon = strtol(dd, &endp, 10);
/* Day */
dd = strtok(NULL, "/");
if (dd == NULL)
return;
nt->net_time_day = strtol(dd, &endp, 10);
/* Year */
dd = strtok(NULL, "/");
if (dd == NULL)
return;
nt->net_time_yr = strtol(dd, &endp, 10);
if (strlen(dd) <= 2)
nt->net_time_yr += 2000;
if (t == NULL)
return;
/* Hour */
h = strtok(t, ":");
if (h == NULL)
return;
nt->net_time_hr = strtol(h, &endp, 10);
/* Min */
h = strtok(NULL, ":");
if (h == NULL)
return;
nt->net_time_min = strtol(h, &endp, 10);
/* Sec */
h = strtok(NULL, ":");
if (h == NULL)
return;
nt->net_time_sec = strtol(h, &endp, 10);
}
/* Get a stat item from an object in the exacct file */
static void
add_stat_item(ea_object_t *o, net_stat_t *ns)
{
switch (o->eo_catalog & EXT_TYPE_MASK) {
case EXT_STRING:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_STATS_NAME) {
(void) strncpy(ns->net_stat_name, o->eo_item.ei_string,
strlen(o->eo_item.ei_string));
}
break;
case EXT_UINT64:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_STATS_CURTIME) {
time_t _time;
char timebuf[TIMEBUFLEN];
ns->net_stat_ctime = o->eo_item.ei_uint64;
_time = ns->net_stat_ctime;
(void) strftime(timebuf, sizeof (timebuf),
"%m/%d/%Y,%T\n", localtime(&_time));
dissect_time(timebuf, &ns->net_stat_time);
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_IBYTES) {
ns->net_stat_ibytes = o->eo_item.ei_uint64;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_OBYTES) {
ns->net_stat_obytes = o->eo_item.ei_uint64;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_IPKTS) {
ns->net_stat_ipackets = o->eo_item.ei_uint64;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_OPKTS) {
ns->net_stat_opackets = o->eo_item.ei_uint64;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_IERRPKTS) {
ns->net_stat_ierrors = o->eo_item.ei_uint64;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_STATS_OERRPKTS) {
ns->net_stat_oerrors = o->eo_item.ei_uint64;
}
break;
default:
break;
}
}
/* Get a description item from an object in the exacct file */
static void
add_desc_item(ea_object_t *o, net_desc_t *nd)
{
switch (o->eo_catalog & EXT_TYPE_MASK) {
case EXT_STRING:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_NAME) {
(void) strncpy(nd->net_desc_name, o->eo_item.ei_string,
strlen(o->eo_item.ei_string));
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_DEVNAME) {
(void) strncpy(nd->net_desc_devname,
o->eo_item.ei_string, strlen(o->eo_item.ei_string));
}
break;
case EXT_UINT8:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_PROTOCOL) {
nd->net_desc_protocol = o->eo_item.ei_uint8;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_DSFIELD) {
nd->net_desc_dsfield = o->eo_item.ei_uint8;
}
break;
case EXT_UINT16:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_SPORT) {
nd->net_desc_sport = o->eo_item.ei_uint16;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_DPORT) {
nd->net_desc_dport = o->eo_item.ei_uint16;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_SAP) {
nd->net_desc_sap = o->eo_item.ei_uint16;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_VLAN_TPID) {
nd->net_desc_vlan_tpid = o->eo_item.ei_uint16;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_VLAN_TCI) {
nd->net_desc_vlan_tci = o->eo_item.ei_uint16;
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_PRIORITY) {
nd->net_desc_priority = o->eo_item.ei_uint16;
}
break;
case EXT_UINT32:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_V4SADDR ||
(o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_V4DADDR) {
struct in_addr addr;
addr.s_addr = htonl(o->eo_item.ei_uint32);
if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_V4SADDR) {
IN6_INADDR_TO_V4MAPPED(&addr,
&nd->net_desc_saddr);
} else {
IN6_INADDR_TO_V4MAPPED(&addr,
&nd->net_desc_daddr);
}
}
break;
case EXT_UINT64:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_BWLIMIT)
nd->net_desc_bw_limit = o->eo_item.ei_uint64;
break;
case EXT_RAW:
if ((o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_V6SADDR ||
(o->eo_catalog & EXD_DATA_MASK) == EXD_NET_DESC_V6DADDR) {
in6_addr_t addr;
addr = *(in6_addr_t *)o->eo_item.ei_raw;
if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_V6SADDR) {
nd->net_desc_saddr = addr;
} else {
nd->net_desc_daddr = addr;
}
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_EHOST) {
bcopy((uchar_t *)o->eo_item.ei_raw, nd->net_desc_ehost,
ETHERADDRL);
} else if ((o->eo_catalog & EXD_DATA_MASK) ==
EXD_NET_DESC_EDEST) {
bcopy((uchar_t *)o->eo_item.ei_raw, nd->net_desc_edest,
ETHERADDRL);
}
break;
default:
break;
}
}
/* Add a description item to the table */
static dladm_status_t
add_desc_to_tbl(net_table_t *net_table, net_desc_t *nd)
{
net_entry_t *ne;
if ((ne = calloc(1, sizeof (net_entry_t))) == NULL)
return (DLADM_STATUS_NOMEM);
if ((ne->net_entry_tstats = calloc(1, sizeof (net_stat_t))) == NULL) {
free(ne);
return (DLADM_STATUS_NOMEM);
}
ne->net_entry_desc = nd;
ne->net_entry_shead = NULL;
ne->net_entry_stail = NULL;
ne->net_entry_scount = 0;
if (net_table->net_table_head == NULL) {
net_table->net_table_head = ne;
net_table->net_table_tail = ne;
} else {
net_table->net_table_tail->net_entry_next = ne;
net_table->net_table_tail = ne;
}
net_table->net_entries++;
return (DLADM_STATUS_OK);
}
/* Compare dates and return if t1 is equal, greater or lesser than t2 */
static int
compare_date(net_time_t *t1, net_time_t *t2)
{
if (t1->net_time_yr == t2->net_time_yr &&
t1->net_time_mon == t2->net_time_mon &&
t1->net_time_day == t2->net_time_day) {
return (NET_DATE_EQUAL);
}
if (t1->net_time_yr > t2->net_time_yr ||
(t1->net_time_yr == t2->net_time_yr &&
t1->net_time_mon > t2->net_time_mon) ||
(t1->net_time_yr == t2->net_time_yr &&
t1->net_time_mon == t2->net_time_mon &&
t1->net_time_day > t2->net_time_day)) {
return (NET_DATE_GREATER);
}
return (NET_DATE_LESSER);
}
/* Compare times and return if t1 is equal, greater or lesser than t2 */
static int
compare_time(net_time_t *t1, net_time_t *t2)
{
int cd;
cd = compare_date(t1, t2);
if (cd == NET_DATE_GREATER) {
return (NET_TIME_GREATER);
} else if (cd == NET_DATE_LESSER) {
return (NET_TIME_LESSER);
} else {
if (t1->net_time_hr == t2->net_time_hr &&
t1->net_time_min == t2->net_time_min &&
t1->net_time_sec == t2->net_time_sec) {
return (NET_TIME_EQUAL);
}
if (t1->net_time_hr > t2->net_time_hr ||
(t1->net_time_hr == t2->net_time_hr &&
t1->net_time_min > t2->net_time_min) ||
(t1->net_time_hr == t2->net_time_hr &&
t1->net_time_min == t2->net_time_min &&
t1->net_time_sec > t2->net_time_sec)) {
return (NET_TIME_GREATER);
}
}
return (NET_TIME_LESSER);
}
/*
* Given a start and end time and start and end entries check if the
* times are within the range, and adjust, if needed.
*/
static dladm_status_t
chk_time_bound(net_time_t *s, net_time_t *e, net_time_t *sns,
net_time_t *ens)
{
if (s != NULL && e != NULL) {
if (compare_time(s, e) == NET_TIME_GREATER)
return (DLADM_STATUS_BADTIMEVAL);
}
if (s != NULL) {
if (compare_time(s, sns) == NET_TIME_LESSER) {
s->net_time_yr = sns->net_time_yr;
s->net_time_mon = sns->net_time_mon;
s->net_time_day = sns->net_time_day;
s->net_time_hr = sns->net_time_hr;
s->net_time_min = sns->net_time_min;
s->net_time_sec = sns->net_time_sec;
}
}
if (e != NULL) {
if (compare_time(e, ens) == NET_TIME_GREATER) {
e->net_time_yr = ens->net_time_yr;
e->net_time_mon = ens->net_time_mon;
e->net_time_day = ens->net_time_day;
e->net_time_hr = ens->net_time_hr;
e->net_time_min = ens->net_time_min;
e->net_time_sec = ens->net_time_sec;
}
}
return (DLADM_STATUS_OK);
}
/*
* Given a start and end time (strings), convert them into net_time_t
* and also check for the range given the head and tail of the list.
* If stime is lower then head or etime is greated than tail, adjust.
*/
static dladm_status_t
get_time_range(net_time_entry_t *head, net_time_entry_t *tail,
net_time_t *st, net_time_t *et, char *stime, char *etime)
{
bzero(st, sizeof (net_time_t));
bzero(et, sizeof (net_time_t));
if (stime == NULL && etime == NULL)
return (0);
if (stime != NULL)
dissect_time(stime, st);
if (etime != NULL)
dissect_time(etime, et);
if (stime != NULL || etime != NULL) {
return (chk_time_bound(stime == NULL ? NULL : st,
etime == NULL ? NULL : et,
&head->my_time_stat->net_stat_time,
&tail->my_time_stat->net_stat_time));
}
return (0);
}
/*
* Walk the list from a given starting point and return when we find
* an entry that is greater or equal to st. lasttime will point to the
* previous time entry.
*/
static void
get_starting_point(net_time_entry_t *head, net_time_entry_t **start,
net_time_t *st, char *stime, uint64_t *lasttime)
{
net_time_entry_t *next = head;
if (head == NULL) {
*start = NULL;
return;
}
if (stime == NULL) {
*start = head;
*lasttime = head->my_time_stat->net_stat_ctime;
return;
}
*start = NULL;
while (next != NULL) {
if (compare_time(st,
&next->my_time_stat->net_stat_time) != NET_TIME_LESSER) {
*lasttime = next->my_time_stat->net_stat_ctime;
next = next->net_time_entry_next;
continue;
}
*start = next;
break;
}
}
/*
* Point entry (pe) functions
*/
/* Clear all the counters. Done after the contents are written to the file */
static void
clear_pe(net_plot_entry_t *pe, int entries, int *pentries)
{
int count;
for (count = 0; count < entries; count++) {
pe[count].net_pe_totbytes = 0;
pe[count].net_pe_totibytes = 0;
pe[count].net_pe_totobytes = 0;
pe[count].net_pe_tottime = 0;
}
*pentries = 0;
}
/* Update an entry in the point entry table */
static void
update_pe(net_plot_entry_t *pe, net_stat_t *nns, int nentries,
int *pentries, uint64_t lasttime)
{
int count;
for (count = 0; count < nentries; count++) {
if (strcmp(pe[count].net_pe_name, nns->net_stat_name) == 0)
break;
}
if (count == nentries)
return;
if (pe[count].net_pe_totbytes == 0)
pe[count].net_pe_lasttime = lasttime;
pe[count].net_pe_totbytes += nns->net_stat_ibytes +
nns->net_stat_obytes;
pe[count].net_pe_tottime += nns->net_stat_tdiff;
pe[count].net_pe_totibytes += nns->net_stat_ibytes;
pe[count].net_pe_totobytes += nns->net_stat_obytes;
(*pentries)++;
}
/* Flush the contents of the point entry table to the file. */
static void
add_pe_to_file(int (*fn)(dladm_usage_t *, void *), net_plot_entry_t *pe,
net_stat_t *ns, int entries, void *arg)
{
int count;
dladm_usage_t usage;
uint64_t tottime;
bcopy(&ns->net_stat_ctime, &usage.du_etime, sizeof (usage.du_etime));
for (count = 0; count < entries; count++) {
bcopy(pe[count].net_pe_name, &usage.du_name,
sizeof (usage.du_name));
bcopy(&pe[count].net_pe_lasttime, &usage.du_stime,
sizeof (usage.du_stime));
usage.du_rbytes = pe[count].net_pe_totibytes;
usage.du_obytes = pe[count].net_pe_totobytes;
tottime = pe[count].net_pe_tottime;
usage.du_bandwidth = (tottime > 0) ?
((pe[count].net_pe_totbytes * 8) / tottime) : 0;
usage.du_last = (count == entries-1);
fn(&usage, arg);
}
}
/*
* Net entry functions
*/
static net_entry_t *
get_ne_from_table(net_table_t *net_table, char *name)
{
int count;
net_desc_t *nd;
net_entry_t *ne = net_table->net_table_head;
for (count = 0; count < net_table->net_entries; count++) {
nd = ne->net_entry_desc;
if (strcmp(name, nd->net_desc_name) == 0)
return (ne);
ne = ne->net_entry_next;
}
return (NULL);
}
/* Get the entry for the descriptor, if it exists */
static net_desc_t *
get_ndesc(net_table_t *net_table, net_desc_t *nd)
{
int count;
net_desc_t *nd1;
net_entry_t *ne = net_table->net_table_head;
for (count = 0; count < net_table->net_entries; count++) {
nd1 = ne->net_entry_desc;
if (strcmp(nd1->net_desc_name, nd->net_desc_name) == 0 &&
strcmp(nd1->net_desc_devname, nd->net_desc_devname) == 0 &&
bcmp(nd1->net_desc_ehost, nd->net_desc_ehost,
ETHERADDRL) == 0 &&
bcmp(nd1->net_desc_edest, nd->net_desc_edest,
ETHERADDRL) == 0 &&
nd1->net_desc_vlan_tpid == nd->net_desc_vlan_tpid &&
nd1->net_desc_vlan_tci == nd->net_desc_vlan_tci &&
nd1->net_desc_sap == nd->net_desc_sap &&
nd1->net_desc_cpuid == nd->net_desc_cpuid &&
nd1->net_desc_priority == nd->net_desc_priority &&
nd1->net_desc_bw_limit == nd->net_desc_bw_limit &&
nd1->net_desc_sport == nd->net_desc_sport &&
nd1->net_desc_dport == nd->net_desc_dport &&
nd1->net_desc_protocol == nd->net_desc_protocol &&
nd1->net_desc_dsfield == nd->net_desc_dsfield &&
IN6_ARE_ADDR_EQUAL(&nd1->net_desc_saddr,
&nd->net_desc_saddr) &&
IN6_ARE_ADDR_EQUAL(&nd1->net_desc_daddr,
&nd->net_desc_daddr)) {
return (nd1);
}
ne = ne->net_entry_next;
}
return (NULL);
}
/*
* Update the stat entries. The stats in the file are cumulative, so in order
* to have increments, we maintain a reference stat entry, which contains
* the stats when the record was first written and a total stat entry, which
* maintains the running count. When we want to add a stat entry, if it
* the reference stat entry, we don't come here. For subsequent entries,
* we get the increment by subtracting the current value from the reference
* stat and the total stat.
*/
static void
update_stats(net_stat_t *ns1, net_entry_t *ne, net_stat_t *ref)
{
/* get the increment */
ns1->net_stat_ibytes -= (ref->net_stat_ibytes + ref->net_stat_tibytes);
ns1->net_stat_obytes -= (ref->net_stat_obytes + ref->net_stat_tobytes);
ns1->net_stat_ipackets -= (ref->net_stat_ipackets +
ref->net_stat_tipackets);
ns1->net_stat_opackets -= (ref->net_stat_opackets +
ref->net_stat_topackets);
ns1->net_stat_ierrors -= (ref->net_stat_ierrors +
ref->net_stat_tierrors);
ns1->net_stat_oerrors -= (ref->net_stat_oerrors +
ref->net_stat_toerrors);
/* update total bytes */
ref->net_stat_tibytes += ns1->net_stat_ibytes;
ref->net_stat_tobytes += ns1->net_stat_obytes;
ref->net_stat_tipackets += ns1->net_stat_ipackets;
ref->net_stat_topackets += ns1->net_stat_opackets;
ref->net_stat_tierrors += ns1->net_stat_ierrors;
ref->net_stat_toerrors += ns1->net_stat_oerrors;
ne->net_entry_tstats->net_stat_ibytes += ns1->net_stat_ibytes;
ne->net_entry_tstats->net_stat_obytes += ns1->net_stat_obytes;
ne->net_entry_tstats->net_stat_ipackets += ns1->net_stat_ipackets;
ne->net_entry_tstats->net_stat_opackets += ns1->net_stat_opackets;
ne->net_entry_tstats->net_stat_ierrors += ns1->net_stat_ierrors;
ne->net_entry_tstats->net_stat_oerrors += ns1->net_stat_oerrors;
}
/* Add the stat entry into the table */
static dladm_status_t
add_stat_to_tbl(net_table_t *net_table, net_stat_t *ns)
{
net_entry_t *ne;
ne = get_ne_from_table(net_table, ns->net_stat_name);
if (ne == NULL)
return (DLADM_STATUS_NOMEM);
/* Ptr to flow desc */
ns->net_stat_desc = ne->net_entry_desc;
if (ns->net_stat_desc->net_desc_newrec) {
ns->net_stat_desc->net_desc_newrec = B_FALSE;
ns->net_stat_isref = B_TRUE;
ne->net_entry_sref = ns;
} else if (ns->net_stat_ibytes < ne->net_entry_sref->net_stat_tibytes ||
(ns->net_stat_obytes < ne->net_entry_sref->net_stat_tobytes)) {
ns->net_stat_isref = B_TRUE;
ne->net_entry_sref = ns;
} else {
ns->net_stat_isref = B_FALSE;
update_stats(ns, ne, ne->net_entry_sref);
}
if (ne->net_entry_shead == NULL) {
ne->net_entry_shead = ns;
ne->net_entry_stail = ns;
} else {
if (!ns->net_stat_isref) {
ne->net_entry_ttime += (ns->net_stat_ctime -
ne->net_entry_stail->net_stat_ctime);
ns->net_stat_tdiff = ns->net_stat_ctime -
ne->net_entry_stail->net_stat_ctime;
}
ne->net_entry_stail->net_stat_next = ns;
ne->net_entry_stail = ns;
}
ne->net_entry_scount++;
return (DLADM_STATUS_OK);
}
/* Add a flow/link descriptor record to the table */
static dladm_status_t
add_desc(net_table_t *net_table, ea_file_t *ef, int nobjs)
{
net_desc_t *nd;
net_desc_t *dnd;
int count;
ea_object_t scratch;
if ((nd = calloc(1, sizeof (net_desc_t))) == NULL)
return (DLADM_STATUS_NOMEM);
nd->net_desc_newrec = B_TRUE;
for (count = 0; count < nobjs; count++) {
if (ea_get_object(ef, &scratch) == -1) {
free(nd);
return (DLADM_STATUS_NOMEM);
}
add_desc_item(&scratch, nd);
}
if ((dnd = get_ndesc(net_table, nd)) != NULL) {
dnd->net_desc_newrec = B_TRUE;
free(nd);
return (DLADM_STATUS_OK);
}
if (add_desc_to_tbl(net_table, nd) != 0) {
free(nd);
return (DLADM_STATUS_NOMEM);
}
return (DLADM_STATUS_OK);
}
/* Make an entry into the time sorted list */
static void
addto_time_list(net_table_t *net_table, net_time_entry_t *nt,
net_time_entry_t *ntc)
{
net_stat_t *ns = nt->my_time_stat;
net_stat_t *ns1;
net_time_entry_t *end;
net_time_t *t1;
int count;
t1 = &ns->net_stat_time;
net_table->net_time_entries++;
if (net_table->net_time_head == NULL) {
net_table->net_time_head = nt;
net_table->net_time_tail = nt;
} else {
net_table->net_time_tail->net_time_entry_next = nt;
nt->net_time_entry_prev = net_table->net_time_tail;
net_table->net_time_tail = nt;
}
if (net_table->net_ctime_head == NULL) {
net_table->net_ctime_head = ntc;
net_table->net_ctime_tail = ntc;
} else {
end = net_table->net_ctime_tail;
count = 0;
while (count < net_table->net_time_entries - 1) {
ns1 = end->my_time_stat;
/* Just add it to the tail */
if (compare_date(t1, &ns1->net_stat_time) ==
NET_DATE_GREATER) {
break;
}
if (strcmp(ns1->net_stat_name, ns->net_stat_name) ==
0) {
ntc->net_time_entry_next =
end->net_time_entry_next;
if (end->net_time_entry_next != NULL) {
end->net_time_entry_next->
net_time_entry_prev = ntc;
} else {
net_table->net_ctime_tail = ntc;
}
end->net_time_entry_next = ntc;
ntc->net_time_entry_prev = end;
return;
}
count++;
end = end->net_time_entry_prev;
}
net_table->net_ctime_tail->net_time_entry_next = ntc;
ntc->net_time_entry_prev = net_table->net_ctime_tail;
net_table->net_ctime_tail = ntc;
}
}
/* Add stat entry into the lists */
static dladm_status_t
add_stats(net_table_t *net_table, ea_file_t *ef, int nobjs)
{
net_stat_t *ns;
int count;
ea_object_t scratch;
net_time_entry_t *nt;
net_time_entry_t *ntc;
if ((ns = calloc(1, sizeof (net_stat_t))) == NULL)
return (DLADM_STATUS_NOMEM);
if ((nt = calloc(1, sizeof (net_time_entry_t))) == NULL) {
free(ns);
return (DLADM_STATUS_NOMEM);
}
if ((ntc = calloc(1, sizeof (net_time_entry_t))) == NULL) {
free(ns);
free(nt);
return (DLADM_STATUS_NOMEM);
}
nt->my_time_stat = ns;
ntc->my_time_stat = ns;
for (count = 0; count < nobjs; count++) {
if (ea_get_object(ef, &scratch) == -1) {
free(ns);
free(nt);
free(ntc);
return (DLADM_STATUS_NOMEM);
}
add_stat_item(&scratch, ns);
}
if (add_stat_to_tbl(net_table, ns) != 0) {
free(ns);
free(nt);
free(ntc);
return (DLADM_STATUS_NOMEM);
}
addto_time_list(net_table, nt, ntc);
return (DLADM_STATUS_OK);
}
/* Free the entire table */
static void
free_logtable(net_table_t *net_table)
{
net_entry_t *head;
net_entry_t *next;
net_stat_t *ns;
net_stat_t *ns1;
net_time_entry_t *thead;
net_time_entry_t *tnext;
thead = net_table->net_time_head;
while (thead != NULL) {
thead->my_time_stat = NULL;
tnext = thead->net_time_entry_next;
thead->net_time_entry_next = NULL;
thead->net_time_entry_prev = NULL;
free(thead);
thead = tnext;
}
net_table->net_time_head = NULL;
net_table->net_time_tail = NULL;
thead = net_table->net_ctime_head;
while (thead != NULL) {
thead->my_time_stat = NULL;
tnext = thead->net_time_entry_next;
thead->net_time_entry_next = NULL;
thead->net_time_entry_prev = NULL;
free(thead);
thead = tnext;
}
net_table->net_ctime_head = NULL;
net_table->net_ctime_tail = NULL;
net_table->net_time_entries = 0;
head = net_table->net_table_head;
while (head != NULL) {
next = head->net_entry_next;
head->net_entry_next = NULL;
ns = head->net_entry_shead;
while (ns != NULL) {
ns1 = ns->net_stat_next;
free(ns);
ns = ns1;
}
head->net_entry_scount = 0;
head->net_entry_sref = NULL;
free(head->net_entry_desc);
free(head->net_entry_tstats);
free(head);
head = next;
}
net_table->net_table_head = NULL;
net_table->net_table_tail = NULL;
net_table->net_time_entries = 0;
free(net_table);
}
/* Parse the exacct file, and return the parsed table. */
static void *
parse_logfile(char *file, int logtype, dladm_status_t *status)
{
ea_file_t ef;
ea_object_t scratch;
net_table_t *net_table;
*status = DLADM_STATUS_OK;
if ((net_table = calloc(1, sizeof (net_table_t))) == NULL) {
*status = DLADM_STATUS_NOMEM;
return (NULL);
}
if (ea_open(&ef, file, NULL, 0, O_RDONLY, 0) == -1) {
*status = DLADM_STATUS_BADARG;
free(net_table);
return (NULL);
}
bzero(&scratch, sizeof (ea_object_t));
while (ea_get_object(&ef, &scratch) != -1) {
if (scratch.eo_type != EO_GROUP) {
(void) ea_free_item(&scratch, EUP_ALLOC);
(void) bzero(&scratch, sizeof (ea_object_t));
continue;
}
/* Read Link Desc/Stat records */
if (logtype == DLADM_LOGTYPE_FLOW) {
/* Flow Descriptor */
if ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_FLOW_DESC) {
(void) add_desc(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
/* Flow Stats */
} else if ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_FLOW_STATS) {
(void) add_stats(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
}
} else if (logtype == DLADM_LOGTYPE_LINK) {
/* Link Descriptor */
if ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_LINK_DESC) {
(void) add_desc(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
/* Link Stats */
} else if ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_LINK_STATS) {
(void) add_stats(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
}
} else {
if (((scratch.eo_catalog & EXD_DATA_MASK) ==
EXD_GROUP_NET_LINK_DESC) || ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_FLOW_DESC)) {
(void) add_desc(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
} else if (((scratch.eo_catalog & EXD_DATA_MASK) ==
EXD_GROUP_NET_LINK_STATS) || ((scratch.eo_catalog &
EXD_DATA_MASK) == EXD_GROUP_NET_FLOW_STATS)) {
(void) add_stats(net_table, &ef,
scratch.eo_group.eg_nobjs - 1);
}
}
(void) ea_free_item(&scratch, EUP_ALLOC);
(void) bzero(&scratch, sizeof (ea_object_t));
}
(void) ea_close(&ef);
return ((void *)net_table);
}
/*
* Walk the ctime list. This is used when looking for usage records
* based on a "resource" name.
*/
dladm_status_t
dladm_walk_usage_res(int (*fn)(dladm_usage_t *, void *), int logtype,
char *logfile, char *resource, char *stime, char *etime, void *arg)
{
net_table_t *net_table;
net_time_t st, et;
net_time_entry_t *start;
net_stat_t *ns = NULL;
net_stat_t *nns;
uint64_t tot_time = 0;
uint64_t last_time;
uint64_t tot_bytes = 0;
uint64_t tot_ibytes = 0;
uint64_t tot_obytes = 0;
boolean_t gotstart = B_FALSE;
dladm_status_t status;
dladm_usage_t usage;
int step = 1;
/* Parse the log file */
net_table = parse_logfile(logfile, logtype, &status);
if (net_table == NULL)
return (status);
if (net_table->net_entries == 0)
return (DLADM_STATUS_OK);
start = net_table->net_ctime_head;
/* Time range */
status = get_time_range(net_table->net_ctime_head,
net_table->net_ctime_tail, &st, &et, stime, etime);
if (status != DLADM_STATUS_OK)
return (status);
while (start != NULL) {
nns = start->my_time_stat;
/* Get to the resource we are interested in */
if (strcmp(resource, nns->net_stat_name) != 0) {
start = start->net_time_entry_next;
continue;
}
/* Find the first record */
if (!gotstart) {
get_starting_point(start, &start, &st, stime,
&last_time);
if (start == NULL)
break;
nns = start->my_time_stat;
gotstart = B_TRUE;
}
/* Write one entry and return if we are out of the range */
if (etime != NULL && compare_time(&nns->net_stat_time, &et)
== NET_TIME_GREATER) {
if (tot_bytes != 0) {
bcopy(ns->net_stat_name, &usage.du_name,
sizeof (usage.du_name));
bcopy(&last_time, &usage.du_stime,
sizeof (usage.du_stime));
bcopy(&ns->net_stat_ctime, &usage.du_etime,
sizeof (usage.du_etime));
usage.du_rbytes = tot_ibytes;
usage.du_obytes = tot_obytes;
usage.du_bandwidth = tot_bytes*8/tot_time;
usage.du_last = B_TRUE;
fn(&usage, arg);
}
return (DLADM_STATUS_OK);
}
/*
* If this is a reference entry, just print what we have
* and proceed.
*/
if (nns->net_stat_isref) {
if (tot_bytes != 0) {
bcopy(&nns->net_stat_name, &usage.du_name,
sizeof (usage.du_name));
bcopy(&nns->net_stat_ctime, &usage.du_stime,
sizeof (usage.du_stime));
usage.du_rbytes = tot_ibytes;
usage.du_obytes = tot_obytes;
usage.du_bandwidth = tot_bytes*8/tot_time;
usage.du_last = B_TRUE;
fn(&usage, arg);
NET_RESET_TOT(tot_bytes, tot_time, tot_ibytes,
tot_obytes, step);
}
last_time = nns->net_stat_ctime;
start = start->net_time_entry_next;
continue;
}
ns = nns;
if (--step == 0) {
tot_bytes += ns->net_stat_ibytes + ns->net_stat_obytes;
tot_ibytes += ns->net_stat_ibytes;
tot_obytes += ns->net_stat_obytes;
tot_time += ns->net_stat_tdiff;
bcopy(&ns->net_stat_name, &usage.du_name,
sizeof (usage.du_name));
bcopy(&last_time, &usage.du_stime,
sizeof (usage.du_stime));
bcopy(&ns->net_stat_ctime, &usage.du_etime,
sizeof (usage.du_etime));
usage.du_rbytes = tot_ibytes;
usage.du_obytes = tot_obytes;
usage.du_bandwidth = tot_bytes*8/tot_time;
usage.du_last = B_TRUE;
fn(&usage, arg);
NET_RESET_TOT(tot_bytes, tot_time, tot_ibytes,
tot_obytes, step);
last_time = ns->net_stat_ctime;
} else {
tot_bytes += ns->net_stat_ibytes + ns->net_stat_obytes;
tot_ibytes += ns->net_stat_ibytes;
tot_obytes += ns->net_stat_obytes;
tot_time += ns->net_stat_tdiff;
}
start = start->net_time_entry_next;
}
if (tot_bytes != 0) {
bcopy(&ns->net_stat_name, &usage.du_name,
sizeof (usage.du_name));
bcopy(&last_time, &usage.du_stime,
sizeof (usage.du_stime));
bcopy(&ns->net_stat_ctime, &usage.du_etime,
sizeof (usage.du_etime));
usage.du_rbytes = tot_ibytes;
usage.du_obytes = tot_obytes;
usage.du_bandwidth = tot_bytes*8/tot_time;
usage.du_last = B_TRUE;
fn(&usage, arg);
}
free_logtable(net_table);
return (status);
}
/*
* Walk the time sorted list if a resource is not specified.
*/
dladm_status_t
dladm_walk_usage_time(int (*fn)(dladm_usage_t *, void *), int logtype,
char *logfile, char *stime, char *etime, void *arg)
{
net_table_t *net_table;
net_time_entry_t *start;
net_stat_t *ns = NULL, *nns;
net_time_t st, et, *t1;
net_desc_t *nd;
net_entry_t *ne;
net_plot_entry_t *pe;
int count;
int step = 1;
int nentries = 0, pentries = 0;
uint64_t last_time;
dladm_status_t status;
/* Parse the log file */
net_table = parse_logfile(logfile, logtype, &status);
if (net_table == NULL)
return (status);
if (net_table->net_entries == 0)
return (DLADM_STATUS_OK);
start = net_table->net_time_head;
/* Find the first and last records and starting point */
status = get_time_range(net_table->net_time_head,
net_table->net_time_tail, &st, &et, stime, etime);
if (status != DLADM_STATUS_OK)
return (status);
get_starting_point(start, &start, &st, stime, &last_time);
/*
* Could assert to be non-null, since get_time_range()
* would have adjusted.
*/
if (start == NULL)
return (DLADM_STATUS_BADTIMEVAL);
/*
* Collect entries for all resources in a time slot before
* writing to the file.
*/
nentries = net_table->net_entries;
pe = malloc(sizeof (net_plot_entry_t) * net_table->net_entries + 1);
if (pe == NULL)
return (DLADM_STATUS_NOMEM);
ne = net_table->net_table_head;
for (count = 0; count < nentries; count++) {
nd = ne->net_entry_desc;
pe[count].net_pe_name = nd->net_desc_name;
ne = ne->net_entry_next;
}
clear_pe(pe, nentries, &pentries);
/* Write header to file */
/* add_pe_to_file(fn, pe, ns, nentries, arg); */
t1 = &start->my_time_stat->net_stat_time;
while (start != NULL) {
nns = start->my_time_stat;
/*
* We have crossed the time boundary, check if we need to
* print out now.
*/
if (compare_time(&nns->net_stat_time, t1) ==
NET_TIME_GREATER) {
/* return if we are out of the range */
if (etime != NULL &&
compare_time(&nns->net_stat_time, &et) ==
NET_TIME_GREATER) {
if (pentries > 0) {
add_pe_to_file(fn, pe, ns, nentries,
arg);
clear_pe(pe, nentries, &pentries);
}
free(pe);
return (DLADM_STATUS_OK);
}
/* update the stats from the ns. */
t1 = &nns->net_stat_time;
last_time = ns->net_stat_ctime;
if (--step == 0) {
if (pentries > 0) {
add_pe_to_file(fn, pe, ns, nentries,
arg);
clear_pe(pe, nentries, &pentries);
}
step = 1;
}
}
/*
* if this is a reference entry, just print what we have
* for this resource and proceed. We will end up writing
* the stats for all the entries when we hit a ref element,
* which means 'steps' for some might not be accurate, but
* that is fine, the alternative is to write only the
* resource for which we hit a reference entry.
*/
if (nns->net_stat_isref) {
if (pentries > 0) {
add_pe_to_file(fn, pe, ns, nentries, arg);
clear_pe(pe, nentries, &pentries);
}
step = 1;
} else {
update_pe(pe, nns, nentries, &pentries, last_time);
}
ns = nns;
start = start->net_time_entry_next;
}
if (pentries > 0)
add_pe_to_file(fn, pe, ns, nentries, arg);
free(pe);
free_logtable(net_table);
return (DLADM_STATUS_OK);
}
dladm_status_t
dladm_usage_summary(int (*fn)(dladm_usage_t *, void *), int logtype,
char *logfile, void *arg)
{
net_table_t *net_table;
net_entry_t *ne;
net_desc_t *nd;
net_stat_t *ns;
int count;
dladm_usage_t usage;
dladm_status_t status;
/* Parse the log file */
net_table = parse_logfile(logfile, logtype, &status);
if (net_table == NULL)
return (status);
if (net_table->net_entries == 0)
return (DLADM_STATUS_OK);
ne = net_table->net_table_head;
for (count = 0; count < net_table->net_entries; count++) {
ns = ne->net_entry_tstats;
nd = ne->net_entry_desc;
if (ns->net_stat_ibytes + ns->net_stat_obytes == 0)
continue;
bcopy(&nd->net_desc_name, &usage.du_name,
sizeof (usage.du_name));
usage.du_duration = ne->net_entry_ttime;
usage.du_ipackets = ns->net_stat_ipackets;
usage.du_rbytes = ns->net_stat_ibytes;
usage.du_opackets = ns->net_stat_opackets;
usage.du_obytes = ns->net_stat_obytes;
usage.du_bandwidth =
(ns->net_stat_ibytes + ns->net_stat_obytes) * 8 /
usage.du_duration;
usage.du_last = (count == net_table->net_entries-1);
fn(&usage, arg);
ne = ne->net_entry_next;
}
free_logtable(net_table);
return (DLADM_STATUS_OK);
}
/*
* Walk the ctime list and display the dates of the records.
*/
dladm_status_t
dladm_usage_dates(int (*fn)(dladm_usage_t *, void *), int logtype,
char *logfile, char *resource, void *arg)
{
net_table_t *net_table;
net_time_entry_t *start;
net_stat_t *nns;
net_time_t st;
net_time_t *lasttime = NULL;
uint64_t last_time;
boolean_t gotstart = B_FALSE;
dladm_status_t status;
dladm_usage_t usage;
/* Parse the log file */
net_table = parse_logfile(logfile, logtype, &status);
if (net_table == NULL)
return (status);
if (net_table->net_entries == 0)
return (DLADM_STATUS_OK);
start = net_table->net_ctime_head;
while (start != NULL) {
nns = start->my_time_stat;
/* get to the resource we are interested in */
if (resource != NULL) {
if (strcmp(resource, nns->net_stat_name) != 0) {
start = start->net_time_entry_next;
continue;
}
}
/* get the starting point in the logfile */
if (!gotstart) {
get_starting_point(start, &start, &st, NULL,
&last_time);
if (start == NULL)
break;
nns = start->my_time_stat;
gotstart = B_TRUE;
}
if (lasttime == NULL ||
compare_date(&nns->net_stat_time, lasttime) ==
NET_DATE_GREATER) {
bzero(&usage, sizeof (dladm_usage_t));
(void) strlcpy(usage.du_name, nns->net_stat_name,
sizeof (usage.du_name));
bcopy(&nns->net_stat_ctime, &usage.du_stime,
sizeof (usage.du_stime));
fn(&usage, arg);
lasttime = &nns->net_stat_time;
}
start = start->net_time_entry_next;
continue;
}
free_logtable(net_table);
return (status);
}