static kstat_t *
task_kstat_create(task_t *tk, zone_t *zone)
{
kstat_t *ksp;
task_kstat_t *ktk;
char *zonename = zone->zone_name;
ksp = rctl_kstat_create_task(tk, "nprocs", KSTAT_TYPE_NAMED,
sizeof (task_kstat_t) / sizeof (kstat_named_t),
KSTAT_FLAG_VIRTUAL);
if (ksp == NULL)
return (NULL);
ktk = ksp->ks_data = kmem_alloc(sizeof (task_kstat_t), KM_SLEEP);
ksp->ks_data_size += strlen(zonename) + 1;
kstat_named_init(&ktk->ktk_zonename, "zonename", KSTAT_DATA_STRING);
kstat_named_setstr(&ktk->ktk_zonename, zonename);
kstat_named_init(&ktk->ktk_usage, "usage", KSTAT_DATA_UINT64);
kstat_named_init(&ktk->ktk_value, "value", KSTAT_DATA_UINT64);
ksp->ks_update = task_nprocs_kstat_update;
ksp->ks_private = tk;
kstat_install(ksp);
return (ksp);
}
/*
* Create the "counters" kstat.
*/
static kstat_t *
ni_create_cntr_kstat(char *name, int instance, int (*update)(kstat_t *, int),
void *ksinfop)
{
struct kstat *counters_ksp;
struct kstat_named *counters_named_data;
char pic_str[10];
int i;
int num_pics = NUM_OF_PICS;
#ifdef DEBUG
if (ni_perf_debug > 1)
printf("ni_create_cntr_kstat: name: %s instance: %d\n",
name, instance);
#endif
/*
* Size of kstat is num_pics + 1 as it
* also contains the %pcr
*/
if ((counters_ksp = kstat_create(name, instance, "counters", "bus",
KSTAT_TYPE_NAMED, num_pics + 1, KSTAT_FLAG_WRITABLE)) == NULL) {
cmn_err(CE_WARN,
"%s: kstat_create for %s%d failed", cpu_module_name,
name, instance);
return (NULL);
}
counters_named_data = (struct kstat_named *)(counters_ksp->ks_data);
/*
* Iinitialize the named kstats
*/
kstat_named_init(&counters_named_data[0], "pcr", KSTAT_DATA_UINT64);
for (i = 0; i < num_pics; i++) {
(void) sprintf(pic_str, "pic%d", i);
kstat_named_init(&counters_named_data[i+1], pic_str,
KSTAT_DATA_UINT64);
}
/*
* Store the register offset's in the kstat's
* private field so that they are available
* to the update function.
*/
counters_ksp->ks_private = (void *)ksinfop;
counters_ksp->ks_update = update;
kstat_install(counters_ksp);
return (counters_ksp);
}
/*
* Create the picN kstat. Returns a pointer to the
* kstat which the driver must store to allow it
* to be deleted when necessary.
*/
static kstat_t *
ni_create_picN_kstat(char *mod_name, int pic, int pic_sel_shift,
int num_ev, ni_kev_mask_t *ev_array)
{
struct kstat_named *pic_named_data;
int inst = 0;
int event;
char pic_name[30];
kstat_t *picN_ksp = NULL;
(void) sprintf(pic_name, "pic%d", pic);
if ((picN_ksp = kstat_create(mod_name, inst, pic_name,
"bus", KSTAT_TYPE_NAMED, num_ev, NULL)) == NULL) {
cmn_err(CE_WARN, "%s %s : kstat create failed",
mod_name, pic_name);
/*
* It is up to the calling function to delete any kstats
* that may have been created already. We just
* return NULL to indicate an error has occured.
*/
return (NULL);
}
pic_named_data = (struct kstat_named *)
picN_ksp->ks_data;
/*
* Write event names and their associated pcr masks. The
* last entry in the array (clear_pic) is added seperately
* below as the pic value must be inverted.
*/
for (event = 0; event < num_ev - 1; event++) {
pic_named_data[event].value.ui64 =
(ev_array[event].pcr_mask << pic_sel_shift);
kstat_named_init(&pic_named_data[event],
ev_array[event].event_name,
KSTAT_DATA_UINT64);
}
/*
* add the clear_pic entry.
*/
pic_named_data[event].value.ui64 =
(uint64_t)~(ev_array[event].pcr_mask << pic_sel_shift);
kstat_named_init(&pic_named_data[event], ev_array[event].event_name,
KSTAT_DATA_UINT64);
kstat_install(picN_ksp);
return (picN_ksp);
}
static kstat_t *
hxge_setup_local_kstat(p_hxge_t hxgep, int instance, char *name,
const hxge_kstat_index_t *ksip, size_t count,
int (*update) (kstat_t *, int))
{
kstat_t *ksp;
kstat_named_t *knp;
int i;
ksp = kstat_create(HXGE_DRIVER_NAME, instance, name, "net",
KSTAT_TYPE_NAMED, count, 0);
if (ksp == NULL)
return (NULL);
ksp->ks_private = (void *) hxgep;
ksp->ks_update = update;
knp = ksp->ks_data;
for (i = 0; ksip[i].name != NULL; i++) {
kstat_named_init(&knp[i], ksip[i].name, ksip[i].type);
}
kstat_install(ksp);
return (ksp);
}
int
drm_init_kstats(drm_device_t *sc)
{
int instance;
kstat_t *ksp;
kstat_named_t *knp;
char *np;
char **aknp;
instance = ddi_get_instance(sc->dip);
aknp = drmkstat_name;
ksp = kstat_create("drm", instance, "drminfo", "drm",
KSTAT_TYPE_NAMED, sizeof (drmkstat_name)/sizeof (char *) - 1,
KSTAT_FLAG_PERSISTENT);
if (ksp == NULL)
return (NULL);
ksp->ks_private = sc;
ksp->ks_update = drm_kstat_update;
for (knp = ksp->ks_data; (np = (*aknp)) != NULL; knp++, aknp++) {
kstat_named_init(knp, np, KSTAT_DATA_UINT32);
}
kstat_install(ksp);
sc->asoft_ksp = ksp;
return (0);
}
/*
* Create the picN kstat. Returns a pointer to the
* kstat which the driver must store to allow it
* to be deleted when necessary.
*/
static kstat_t *
iospc_create_picN_kstat(char *mod_name, int pic, uint64_t ev_offset,
int num_ev, iospc_event_t *ev_array)
{
int event;
char pic_name[PIC_STR_LEN];
kstat_t *picN_ksp = NULL;
struct kstat_named *pic_named_data;
(void) snprintf(pic_name, PIC_STR_LEN, "pic%1d", pic);
if ((picN_ksp = kstat_create(mod_name, 0, pic_name,
"bus", KSTAT_TYPE_NAMED, num_ev, NULL)) == NULL) {
return (NULL);
}
/* NOTE: Number of events is assumed to always be non-zero. */
pic_named_data = (struct kstat_named *)picN_ksp->ks_data;
/*
* Fill up data section of the kstat
* Write event names and their associated pcr masks.
* num_ev - 1 is because CLEAR_PIC is added separately.
*/
for (event = 0; event < num_ev - 1; event++) {
pic_named_data[event].value.ui64 =
ev_array[event].value << ev_offset;
kstat_named_init(&pic_named_data[event],
ev_array[event].name, KSTAT_DATA_UINT64);
}
/*
* add the clear_pic entry
*/
pic_named_data[event].value.ui64 =
(uint64_t)~(ev_array[event].value << ev_offset);
kstat_named_init(&pic_named_data[event], ev_array[event].name,
KSTAT_DATA_UINT64);
kstat_install(picN_ksp);
return (picN_ksp);
}
/*
* Create the "counters" kstat.
*/
kstat_t *pcmu_create_cntr_kstat(pcmu_t *pcmu_p, char *name,
int num_pics, int (*update)(kstat_t *, int),
void *cntr_addr_p)
{
struct kstat_named *counters_named_data;
struct kstat *counters_ksp;
dev_info_t *dip = pcmu_p->pcmu_dip;
char *drv_name = (char *)ddi_driver_name(dip);
int drv_instance = ddi_get_instance(dip);
char pic_str[10];
int i;
/*
* Size of kstat is num_pics + 1 as it
* also contains the %pcr
*/
if ((counters_ksp = kstat_create(name, drv_instance,
"counters", "bus", KSTAT_TYPE_NAMED, num_pics + 1,
KSTAT_FLAG_WRITABLE)) == NULL) {
cmn_err(CE_WARN, "%s%d counters kstat_create failed",
drv_name, drv_instance);
return (NULL);
}
counters_named_data = (struct kstat_named *)(counters_ksp->ks_data);
/* initialize the named kstats */
kstat_named_init(&counters_named_data[0], "pcr", KSTAT_DATA_UINT64);
for (i = 0; i < num_pics; i++) {
(void) sprintf(pic_str, "pic%d", i);
kstat_named_init(&counters_named_data[i+1],
pic_str, KSTAT_DATA_UINT64);
}
/*
* Store the register offset's in the kstat's
* private field so that they are available
* to the update function.
*/
counters_ksp->ks_private = (void *)cntr_addr_p;
counters_ksp->ks_update = update;
kstat_install(counters_ksp);
return (counters_ksp);
}
static void
i_mac_kstat_init(kstat_named_t *knp, mac_stat_info_t *si, uint_t count)
{
int i;
for (i = 0; i < count; i++) {
kstat_named_init(knp, si[i].msi_name, si[i].msi_type);
knp++;
}
}
/*
* Create the "counters" kstat.
*/
static kstat_t *
iospc_create_cntr_kstat(char *name, int dev_inst,
int (*update)(kstat_t *, int), iospc_ksinfo_t *ksinfop, int num_pics)
{
int i;
char pic_str[PIC_STR_LEN];
struct kstat *counters_ksp;
struct kstat_named *counters_named_data;
IOSPC_DBG2("iospc_create_cntr_kstat: name: %s instance: %d\n",
name, dev_inst);
/*
* Size of kstat is num_pics + 1. extra one for pcr.
*/
if ((counters_ksp = kstat_create(name, dev_inst, "counters", "bus",
KSTAT_TYPE_NAMED, num_pics + 1, KSTAT_FLAG_WRITABLE)) == NULL) {
return (NULL);
}
counters_named_data = (struct kstat_named *)(counters_ksp->ks_data);
kstat_named_init(&counters_named_data[0], "pcr", KSTAT_DATA_UINT64);
for (i = 0; i < num_pics; i++) {
(void) snprintf(pic_str, PIC_STR_LEN, "pic%1d", i);
kstat_named_init(&counters_named_data[i+1], pic_str,
KSTAT_DATA_UINT64);
}
/*
* Store the reg type and other info. in the kstat's private field
* so that they are available to the update function.
*/
counters_ksp->ks_private = (void *)ksinfop;
counters_ksp->ks_update = update;
kstat_install(counters_ksp);
return (counters_ksp);
}
/*
* dcopy_stats_init()
*/
static int
dcopy_stats_init(dcopy_handle_t channel)
{
#define CHANSTRSIZE 20
char chanstr[CHANSTRSIZE];
dcopy_stats_t *stats;
int instance;
char *name;
stats = &channel->ch_stat;
name = (char *)ddi_driver_name(channel->ch_device->dc_info.di_dip);
instance = ddi_get_instance(channel->ch_device->dc_info.di_dip);
(void) snprintf(chanstr, CHANSTRSIZE, "channel%d",
(uint32_t)channel->ch_info.qc_chan_num);
channel->ch_kstat = kstat_create(name, instance, chanstr, "misc",
KSTAT_TYPE_NAMED, sizeof (dcopy_stats_t) / sizeof (kstat_named_t),
KSTAT_FLAG_VIRTUAL);
if (channel->ch_kstat == NULL) {
return (DCOPY_FAILURE);
}
channel->ch_kstat->ks_data = stats;
kstat_named_init(&stats->cs_bytes_xfer, "bytes_xfer",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_cmd_alloc, "cmd_alloc",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_cmd_post, "cmd_post",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_cmd_poll, "cmd_poll",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_notify_poll, "notify_poll",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_notify_pending, "notify_pending",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_id, "id",
KSTAT_DATA_UINT64);
kstat_named_init(&stats->cs_capabilities, "capabilities",
KSTAT_DATA_UINT64);
kstat_install(channel->ch_kstat);
channel->ch_stat.cs_id.value.ui64 = channel->ch_info.qc_id;
channel->ch_stat.cs_capabilities.value.ui64 =
channel->ch_info.qc_capabilities;
return (DCOPY_SUCCESS);
}
/*
* Create interrupt kstats for this CPU.
*/
void
cpu_create_intrstat(cpu_t *cp)
{
int i;
kstat_t *intr_ksp;
kstat_named_t *knp;
char name[KSTAT_STRLEN];
zoneid_t zoneid;
ASSERT(MUTEX_HELD(&cpu_lock));
if (pool_pset_enabled())
zoneid = GLOBAL_ZONEID;
else
zoneid = ALL_ZONES;
intr_ksp = kstat_create_zone("cpu", cp->cpu_id, "intrstat", "misc",
KSTAT_TYPE_NAMED, PIL_MAX * 2, NULL, zoneid);
/*
* Initialize each PIL's named kstat
*/
if (intr_ksp != NULL) {
intr_ksp->ks_update = cpu_kstat_intrstat_update;
knp = (kstat_named_t *)intr_ksp->ks_data;
intr_ksp->ks_private = cp;
for (i = 0; i < PIL_MAX; i++) {
(void) snprintf(name, KSTAT_STRLEN, "level-%d-time",
i + 1);
kstat_named_init(&knp[i * 2], name, KSTAT_DATA_UINT64);
(void) snprintf(name, KSTAT_STRLEN, "level-%d-count",
i + 1);
kstat_named_init(&knp[(i * 2) + 1], name,
KSTAT_DATA_UINT64);
}
kstat_install(intr_ksp);
}
}
static void
cpupart_kstat_create(cpupart_t *cp)
{
kstat_t *ksp;
zoneid_t zoneid;
ASSERT(MUTEX_HELD(&cpu_lock));
/*
* We have a bit of a chicken-egg problem since this code will
* get called to create the kstats for CP_DEFAULT before the
* pools framework gets initialized. We circumvent the problem
* by special-casing cp_default.
*/
if (cp != &cp_default && pool_pset_enabled())
zoneid = GLOBAL_ZONEID;
else
zoneid = ALL_ZONES;
ksp = kstat_create_zone("unix", cp->cp_id, "pset", "misc",
KSTAT_TYPE_NAMED,
sizeof (cpupart_kstat_t) / sizeof (kstat_named_t), 0, zoneid);
if (ksp != NULL) {
cpupart_kstat_t *cpksp = ksp->ks_data;
kstat_named_init(&cpksp->cpk_updates, "updates",
KSTAT_DATA_UINT64);
kstat_named_init(&cpksp->cpk_runnable, "runnable",
KSTAT_DATA_UINT64);
kstat_named_init(&cpksp->cpk_waiting, "waiting",
KSTAT_DATA_UINT64);
kstat_named_init(&cpksp->cpk_ncpus, "ncpus",
KSTAT_DATA_UINT32);
kstat_named_init(&cpksp->cpk_avenrun_1min, "avenrun_1min",
KSTAT_DATA_UINT32);
kstat_named_init(&cpksp->cpk_avenrun_5min, "avenrun_5min",
KSTAT_DATA_UINT32);
kstat_named_init(&cpksp->cpk_avenrun_15min, "avenrun_15min",
KSTAT_DATA_UINT32);
ksp->ks_update = cpupart_kstat_update;
ksp->ks_private = cp;
kstat_install(ksp);
}
cp->cp_kstat = ksp;
}
static kstat_t *
bge_setup_named_kstat(bge_t *bgep, int instance, char *name,
const bge_ksindex_t *ksip, size_t size, int (*update)(kstat_t *, int))
{
kstat_t *ksp;
kstat_named_t *knp;
char *np;
int type;
size /= sizeof (bge_ksindex_t);
ksp = kstat_create(BGE_DRIVER_NAME, instance, name, "net",
KSTAT_TYPE_NAMED, size-1, 0);
if (ksp == NULL)
return (NULL);
ksp->ks_private = bgep;
ksp->ks_update = update;
for (knp = ksp->ks_data; (np = ksip->name) != NULL; ++knp, ++ksip) {
switch (*np) {
default:
type = KSTAT_DATA_UINT64;
break;
case '%':
np += 1;
type = KSTAT_DATA_UINT32;
break;
case '$':
np += 1;
type = KSTAT_DATA_STRING;
break;
case '&':
np += 1;
type = KSTAT_DATA_CHAR;
break;
}
kstat_named_init(knp, np, type);
}
kstat_install(ksp);
return (ksp);
}
/*
* function to setup the kstat_t structure for the device and install it
*
* dev - software handle to the device
*
* return DDI_SUCCESS => success, failure otherwise
*/
int
oce_stat_init(struct oce_dev *dev)
{
struct oce_stat *stats;
uint32_t num_stats = sizeof (struct oce_stat) /
sizeof (kstat_named_t);
/* allocate the kstat */
dev->oce_kstats = kstat_create(OCE_MOD_NAME, dev->dev_id, "stats",
"net", KSTAT_TYPE_NAMED,
num_stats, 0);
if (dev->oce_kstats == NULL) {
oce_log(dev, CE_NOTE, MOD_CONFIG,
"kstat creation failed: 0x%p",
(void *)dev->oce_kstats);
return (DDI_FAILURE);
}
/* allocate the device copy of the stats */
dev->stats_dbuf = oce_alloc_dma_buffer(dev,
sizeof (struct mbx_get_nic_stats),
NULL, DDI_DMA_CONSISTENT);
if (dev->stats_dbuf == NULL) {
oce_log(dev, CE_NOTE, MOD_CONFIG,
"Could not allocate stats_dbuf: %p",
(void *)dev->stats_dbuf);
kstat_delete(dev->oce_kstats);
return (DDI_FAILURE);
}
dev->hw_stats = (struct mbx_get_nic_stats *)DBUF_VA(dev->stats_dbuf);
/* initialize the counters */
stats = (struct oce_stat *)dev->oce_kstats->ks_data;
kstat_named_init(&stats->rx_bytes_hi, "rx bytes msd", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_bytes_lo, "rx bytes lsd", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_frames, "rx frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_errors, "rx errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops, "rx drops", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_bytes_hi, "tx bytes msd", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_bytes_lo, "tx bytes lsd", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_frames, "tx frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_errors, "tx errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_unicast_frames,
"rx unicast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_multicast_frames,
"rx multicast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_broadcast_frames,
"rx broadcast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_crc_errors,
"rx crc errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_alignment_symbol_errors,
"rx alignment symbol errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_in_range_errors,
"rx in range errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_out_range_errors,
"rx out range errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_frame_too_long,
"rx frame too long", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_address_match_errors,
"rx address match errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_pause_frames,
"rx pause frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_control_frames,
"rx control frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_ip_checksum_errs,
"rx ip checksum errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_tcp_checksum_errs,
"rx tcp checksum errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_udp_checksum_errs,
"rx udp checksum errors", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_fifo_overflow,
"rx fifo overflow", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_input_fifo_overflow,
"rx input fifo overflow", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_unicast_frames,
"tx unicast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_multicast_frames,
"tx multicast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_broadcast_frames,
"tx broadcast frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_pause_frames,
"tx pause frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->tx_control_frames,
"tx control frames", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_no_pbuf,
"rx_drops_no_pbuf", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_no_txpb,
"rx_drops_no_txpb", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_no_erx_descr,
"rx_drops_no_erx_descr", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_no_tpre_descr,
"rx_drops_no_tpre_descr", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_too_many_frags,
"rx_drops_too_many_frags", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_invalid_ring,
"rx_drops_invalid_ring", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_mtu,
"rx_drops_mtu", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_dropped_too_small,
"rx_dropped_too_small", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_dropped_too_short,
"rx_dropped_too_short", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_dropped_header_too_small,
"rx_dropped_header_too_small", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_dropped_tcp_length,
"rx_dropped_tcp_length", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_dropped_runt,
"rx_dropped_runt", KSTAT_DATA_ULONG);
kstat_named_init(&stats->rx_drops_no_fragments,
"rx_drop_no_frag", KSTAT_DATA_ULONG);
dev->oce_kstats->ks_update = oce_update_stats;
dev->oce_kstats->ks_private = (void *)dev;
kstat_install(dev->oce_kstats);
return (DDI_SUCCESS);
} /* oce_stat_init */
void
hxge_setup_kstats(p_hxge_t hxgep)
{
struct kstat *ksp;
p_hxge_port_kstat_t hxgekp;
size_t hxge_kstat_sz;
char stat_name[64];
int i;
HXGE_DEBUG_MSG((hxgep, KST_CTL, "==> hxge_setup_kstats"));
/* Setup RDC statistics */
for (i = 0; i < hxgep->nrdc; i++) {
(void) sprintf(stat_name, "%s"CH_NAME_FORMAT,
RDC_NAME_FORMAT1, i);
hxgep->statsp->rdc_ksp[i] = hxge_setup_local_kstat(hxgep,
hxgep->instance, stat_name, &hxge_rdc_stats[0],
RDC_STAT_END, hxge_rdc_stat_update);
if (hxgep->statsp->rdc_ksp[i] == NULL)
cmn_err(CE_WARN,
"kstat_create failed for rdc channel %d", i);
}
/* Setup RDC System statistics */
hxgep->statsp->rdc_sys_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "RDC_system", &hxge_rdc_sys_stats[0],
RDC_SYS_STAT_END, hxge_rdc_sys_stat_update);
if (hxgep->statsp->rdc_sys_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for rdc_sys_ksp");
/* Setup TDC statistics */
for (i = 0; i < hxgep->ntdc; i++) {
(void) sprintf(stat_name, "%s"CH_NAME_FORMAT,
TDC_NAME_FORMAT1, i);
hxgep->statsp->tdc_ksp[i] = hxge_setup_local_kstat(hxgep,
hxgep->instance, stat_name, &hxge_tdc_stats[0],
TDC_STAT_END, hxge_tdc_stat_update);
if (hxgep->statsp->tdc_ksp[i] == NULL)
cmn_err(CE_WARN,
"kstat_create failed for tdc channel %d", i);
}
/* Setup TDC System statistics */
hxgep->statsp->tdc_sys_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "TDC_system", &hxge_tdc_sys_stats[0],
RDC_SYS_STAT_END, hxge_tdc_sys_stat_update);
if (hxgep->statsp->tdc_sys_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for tdc_sys_ksp");
/* Setup PFC statistics */
hxgep->statsp->pfc_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "PFC", &hxge_pfc_stats[0],
PFC_STAT_END, hxge_pfc_stat_update);
if (hxgep->statsp->pfc_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for pfc");
/* Setup VMAC statistics */
hxgep->statsp->vmac_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "VMAC", &hxge_vmac_stats[0],
VMAC_STAT_END, hxge_vmac_stat_update);
if (hxgep->statsp->vmac_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for vmac");
/* Setup MMAC Statistics. */
hxgep->statsp->mmac_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "MMAC", &hxge_mmac_stats[0],
MMAC_STATS_END, hxge_mmac_stat_update);
if (hxgep->statsp->mmac_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for mmac");
/* Setup PEU System statistics */
hxgep->statsp->peu_sys_ksp = hxge_setup_local_kstat(hxgep,
hxgep->instance, "PEU", &hxge_peu_sys_stats[0],
PEU_SYS_STAT_END, hxge_peu_sys_stat_update);
if (hxgep->statsp->peu_sys_ksp == NULL)
cmn_err(CE_WARN, "kstat_create failed for peu sys");
/* Port stats */
hxge_kstat_sz = sizeof (hxge_port_kstat_t);
if ((ksp = kstat_create(HXGE_DRIVER_NAME, hxgep->instance,
"Port", "net", KSTAT_TYPE_NAMED,
hxge_kstat_sz / sizeof (kstat_named_t), 0)) == NULL) {
cmn_err(CE_WARN, "kstat_create failed for port stat");
return;
}
hxgekp = (p_hxge_port_kstat_t)ksp->ks_data;
kstat_named_init(&hxgekp->cap_10gfdx, "cap_10gfdx", KSTAT_DATA_ULONG);
/*
* Link partner capabilities.
*/
kstat_named_init(&hxgekp->lp_cap_10gfdx, "lp_cap_10gfdx",
KSTAT_DATA_ULONG);
/*
* Shared link setup.
*/
kstat_named_init(&hxgekp->link_speed, "link_speed", KSTAT_DATA_ULONG);
kstat_named_init(&hxgekp->link_duplex, "link_duplex", KSTAT_DATA_CHAR);
kstat_named_init(&hxgekp->link_up, "link_up", KSTAT_DATA_ULONG);
/*
* Loopback statistics.
*/
kstat_named_init(&hxgekp->lb_mode, "lb_mode", KSTAT_DATA_ULONG);
/* General MAC statistics */
kstat_named_init(&hxgekp->ifspeed, "ifspeed", KSTAT_DATA_UINT64);
kstat_named_init(&hxgekp->promisc, "promisc", KSTAT_DATA_CHAR);
ksp->ks_update = hxge_port_kstat_update;
ksp->ks_private = (void *) hxgep;
kstat_install(ksp);
hxgep->statsp->port_ksp = ksp;
HXGE_DEBUG_MSG((hxgep, KST_CTL, "<== hxge_setup_kstats"));
}
static void
dadk_create_errstats(struct dadk *dadkp, int instance)
{
dadk_errstats_t *dep;
char kstatname[KSTAT_STRLEN];
dadk_ioc_string_t dadk_ioc_string;
if (dadkp->dad_errstats)
return;
(void) sprintf(kstatname, "cmdk%d,error", instance);
dadkp->dad_errstats = kstat_create("cmdkerror", instance,
kstatname, "device_error", KSTAT_TYPE_NAMED,
sizeof (dadk_errstats_t) / sizeof (kstat_named_t),
KSTAT_FLAG_PERSISTENT);
if (!dadkp->dad_errstats)
return;
dep = (dadk_errstats_t *)dadkp->dad_errstats->ks_data;
kstat_named_init(&dep->dadk_softerrs,
"Soft Errors", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_harderrs,
"Hard Errors", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_transerrs,
"Transport Errors", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_model,
"Model", KSTAT_DATA_CHAR);
kstat_named_init(&dep->dadk_revision,
"Revision", KSTAT_DATA_CHAR);
kstat_named_init(&dep->dadk_serial,
"Serial No", KSTAT_DATA_CHAR);
kstat_named_init(&dep->dadk_capacity,
"Size", KSTAT_DATA_ULONGLONG);
kstat_named_init(&dep->dadk_rq_media_err,
"Media Error", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_rq_ntrdy_err,
"Device Not Ready", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_rq_nodev_err,
"No Device", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_rq_recov_err,
"Recoverable", KSTAT_DATA_UINT32);
kstat_named_init(&dep->dadk_rq_illrq_err,
"Illegal Request", KSTAT_DATA_UINT32);
dadkp->dad_errstats->ks_private = dep;
dadkp->dad_errstats->ks_update = nulldev;
kstat_install(dadkp->dad_errstats);
/* get model */
dep->dadk_model.value.c[0] = 0;
dadk_ioc_string.is_buf = &dep->dadk_model.value.c[0];
dadk_ioc_string.is_size = sizeof (dep->dadk_model.value.c);
(void) dadk_ctl_ioctl(dadkp, DIOCTL_GETMODEL,
(uintptr_t)&dadk_ioc_string, FKIOCTL | FNATIVE);
/* get serial */
dep->dadk_serial.value.c[0] = 0;
dadk_ioc_string.is_buf = &dep->dadk_serial.value.c[0];
dadk_ioc_string.is_size = sizeof (dep->dadk_serial.value.c);
(void) dadk_ctl_ioctl(dadkp, DIOCTL_GETSERIAL,
(uintptr_t)&dadk_ioc_string, FKIOCTL | FNATIVE);
/* Get revision */
dep->dadk_revision.value.c[0] = 0;
/* Get capacity */
dep->dadk_capacity.value.ui64 =
(uint64_t)dadkp->dad_logg.g_cap *
(uint64_t)dadkp->dad_logg.g_secsiz;
}
/*
* Create and initialize the driver private statistics.
*/
int
igb_init_stats(igb_t *igb)
{
kstat_t *ks;
igb_stat_t *igb_ks;
/*
* Create and init kstat
*/
ks = kstat_create(MODULE_NAME, ddi_get_instance(igb->dip),
"statistics", "net", KSTAT_TYPE_NAMED,
sizeof (igb_stat_t) / sizeof (kstat_named_t), 0);
if (ks == NULL) {
igb_error(igb,
"Could not create kernel statistics");
return (IGB_FAILURE);
}
igb->igb_ks = ks;
igb_ks = (igb_stat_t *)ks->ks_data;
/*
* Initialize all the statistics.
*/
kstat_named_init(&igb_ks->reset_count, "reset_count",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->dout_sync, "DMA_out_sync",
KSTAT_DATA_UINT64);
#ifdef IGB_DEBUG
kstat_named_init(&igb_ks->rx_frame_error, "rx_frame_error",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->rx_cksum_error, "rx_cksum_error",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->rx_exceed_pkt, "rx_exceed_pkt",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tx_overload, "tx_overload",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tx_fail_no_tbd, "tx_fail_no_tbd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tx_fail_no_tcb, "tx_fail_no_tcb",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tx_fail_dma_bind, "tx_fail_dma_bind",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tx_reschedule, "tx_reschedule",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->gprc, "good_pkts_recvd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->gptc, "good_pkts_xmitd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->gor, "good_octets_recvd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->got, "good_octets_xmitd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc64, "pkts_recvd_( 64b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc127, "pkts_recvd_( 65- 127b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc255, "pkts_recvd_( 127- 255b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc511, "pkts_recvd_( 256- 511b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc1023, "pkts_recvd_( 511-1023b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->prc1522, "pkts_recvd_(1024-1522b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc64, "pkts_xmitd_( 64b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc127, "pkts_xmitd_( 65- 127b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc255, "pkts_xmitd_( 128- 255b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc511, "pkts_xmitd_( 255- 511b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc1023, "pkts_xmitd_( 512-1023b)",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->ptc1522, "pkts_xmitd_(1024-1522b)",
KSTAT_DATA_UINT64);
#endif
kstat_named_init(&igb_ks->symerrs, "recv_symbol_errors",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->mpc, "recv_missed_packets",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->rlec, "recv_length_errors",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->fcruc, "recv_unsupport_FC_pkts",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->rfc, "recv_frag",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tncrs, "xmit_with_no_CRS",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tsctc, "xmit_TCP_seg_contexts",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->tsctfc, "xmit_TCP_seg_contexts_fail",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->xonrxc, "XONs_recvd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->xontxc, "XONs_xmitd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->xoffrxc, "XOFFs_recvd",
KSTAT_DATA_UINT64);
kstat_named_init(&igb_ks->xofftxc, "XOFFs_xmitd",
KSTAT_DATA_UINT64);
/*
* Function to provide kernel stat update on demand
*/
ks->ks_update = igb_update_stats;
ks->ks_private = (void *)igb;
/*
* Add kstat to systems kstat chain
*/
kstat_install(ks);
return (IGB_SUCCESS);
}
/*
* Initialize drop facility kstats.
*/
void
ip_drop_init(void)
{
ip_drop_kstat = kstat_create("ip", 0, "ipdrop", "net",
KSTAT_TYPE_NAMED, sizeof (*ip_drop_types) / sizeof (kstat_named_t),
KSTAT_FLAG_PERSISTENT);
if (ip_drop_kstat == NULL)
return;
ip_drop_types = ip_drop_kstat->ks_data;
/* TCP IPsec drop statistics. */
kstat_named_init(&ipdrops_tcp_clear, "tcp_clear", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_tcp_secure, "tcp_secure", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_tcp_mismatch, "tcp_mismatch",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_tcp_ipsec_alloc, "tcp_ipsec_alloc",
KSTAT_DATA_UINT64);
/* SADB-specific drop statistics. */
kstat_named_init(&ipdrops_sadb_inlarval_timeout,
"sadb_inlarval_timeout", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_sadb_inlarval_replace,
"sadb_inlarval_replace", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_sadb_acquire_nomem,
"sadb_acquire_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_sadb_acquire_toofull,
"sadb_acquire_toofull", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_sadb_acquire_timeout,
"sadb_acquire_timeout", KSTAT_DATA_UINT64);
/* SPD drop statistics. */
kstat_named_init(&ipdrops_spd_ahesp_diffid, "spd_ahesp_diffid",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_loopback_mismatch,
"spd_loopback_mismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_explicit, "spd_explicit",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_got_secure, "spd_got_secure",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_got_clear, "spd_got_clear",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_bad_ahalg, "spd_bad_ahalg",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_got_ah, "spd_got_ah", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_bad_espealg, "spd_bad_espealg",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_bad_espaalg, "spd_bad_espaalg",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_got_esp, "spd_got_esp",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_got_selfencap, "spd_got_selfencap",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_bad_selfencap, "spd_bad_selfencap",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_nomem, "spd_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_ah_badid, "spd_ah_badid",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_esp_badid, "spd_esp_badid",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_ah_innermismatch,
"spd_ah_innermismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_spd_esp_innermismatch,
"spd_esp_innermismatch", KSTAT_DATA_UINT64);
/* ESP-specific drop statistics. */
kstat_named_init(&ipdrops_esp_nomem, "esp_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_no_sa, "esp_no_sa", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_early_replay, "esp_early_replay",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_replay, "esp_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_bytes_expire, "esp_bytes_expire",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_bad_padlen, "esp_bad_padlen",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_bad_padding, "esp_bad_padding",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_bad_auth, "esp_bad_auth",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_crypto_failed, "esp_crypto_failed",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_esp_icmp, "esp_icmp", KSTAT_DATA_UINT64);
/* AH-specific drop statistics. */
kstat_named_init(&ipdrops_ah_nomem, "ah_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_bad_v6_hdrs, "ah_bad_v6_hdrs",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_bad_v4_opts, "ah_bad_v4_opts",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_no_sa, "ah_no_sa", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_bad_length, "ah_bad_length",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_bad_auth, "ah_bad_auth",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_crypto_failed, "ah_crypto_failed",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_early_replay, "ah_early_replay",
KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_replay, "ah_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipdrops_ah_bytes_expire, "ah_bytes_expire",
KSTAT_DATA_UINT64);
/* IP-specific drop statistics. */
kstat_named_init(&ipdrops_ip_ipsec_not_loaded, "ip_ipsec_not_loaded",
KSTAT_DATA_UINT64);
kstat_install(ip_drop_kstat);
}
/*
* Initialize drop facility kstats.
*/
void
ip_drop_init(ipsec_stack_t *ipss)
{
ipss->ipsec_ip_drop_kstat = kstat_create_netstack("ip", 0, "ipdrop",
"net", KSTAT_TYPE_NAMED,
sizeof (struct ip_dropstats) / sizeof (kstat_named_t),
KSTAT_FLAG_PERSISTENT, ipss->ipsec_netstack->netstack_stackid);
if (ipss->ipsec_ip_drop_kstat == NULL ||
ipss->ipsec_ip_drop_kstat->ks_data == NULL)
return;
/*
* Note: here ipss->ipsec_ip_drop_types is initialized, however,
* if the previous kstat_create_netstack failed, it will remain
* NULL. Note this is done for all stack instances, so it *could*
* be NULL. Hence a non-NULL checking is added where
* ipss->ipsec_ip_drop_types is used. This checking is hidden in
* the DROPPER macro.
*/
ipss->ipsec_ip_drop_types = ipss->ipsec_ip_drop_kstat->ks_data;
/* TCP IPsec drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_tcp_clear,
"tcp_clear", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_tcp_secure,
"tcp_secure", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_tcp_mismatch,
"tcp_mismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_tcp_ipsec_alloc,
"tcp_ipsec_alloc", KSTAT_DATA_UINT64);
/* SADB-specific drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_inlarval_timeout,
"sadb_inlarval_timeout", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_inlarval_replace,
"sadb_inlarval_replace", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_inidle_overflow,
"sadb_inidle_overflow", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_inidle_timeout,
"sadb_inidle_timeout", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_acquire_nomem,
"sadb_acquire_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_acquire_toofull,
"sadb_acquire_toofull", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_sadb_acquire_timeout,
"sadb_acquire_timeout", KSTAT_DATA_UINT64);
/* SPD drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_ahesp_diffid,
"spd_ahesp_diffid", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_loopback_mismatch,
"spd_loopback_mismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_explicit,
"spd_explicit", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_got_secure,
"spd_got_secure", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_got_clear,
"spd_got_clear", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_bad_ahalg,
"spd_bad_ahalg", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_got_ah,
"spd_got_ah", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_bad_espealg,
"spd_bad_espealg", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_bad_espaalg,
"spd_bad_espaalg", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_got_esp,
"spd_got_esp", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_got_selfencap,
"spd_got_selfencap", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_bad_selfencap,
"spd_bad_selfencap", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_nomem,
"spd_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_ah_badid,
"spd_ah_badid", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_ah_innermismatch,
"spd_ah_innermismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_esp_innermismatch,
"spd_esp_innermismatch", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_esp_badid,
"spd_esp_badid", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_no_policy,
"spd_no_policy", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_malformed_packet,
"spd_malformed_packet", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_malformed_frag,
"spd_malformed_frag", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_overlap_frag,
"spd_overlap_frag", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_evil_frag,
"spd_evil_frag", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_spd_max_frags,
"spd_max_frags", KSTAT_DATA_UINT64);
/* ESP-specific drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_nomem,
"esp_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_no_sa,
"esp_no_sa", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_early_replay,
"esp_early_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_replay,
"esp_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_bytes_expire,
"esp_bytes_expire", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_bad_padlen,
"esp_bad_padlen", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_bad_padding,
"esp_bad_padding", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_bad_auth,
"esp_bad_auth", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_crypto_failed,
"esp_crypto_failed", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_icmp,
"esp_icmp", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_nat_t_ipsec,
"esp_nat_t_ipsec", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_nat_t_ka,
"esp_nat_t_ka", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_esp_iv_wrap,
"esp_iv_wrap", KSTAT_DATA_UINT64);
/* AH-specific drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_nomem,
"ah_nomem", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_bad_v6_hdrs,
"ah_bad_v6_hdrs", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_bad_v4_opts,
"ah_bad_v4_opts", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_no_sa,
"ah_no_sa", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_bad_length,
"ah_bad_length", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_bad_auth,
"ah_bad_auth", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_crypto_failed,
"ah_crypto_failed", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_early_replay,
"ah_early_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_replay,
"ah_replay", KSTAT_DATA_UINT64);
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ah_bytes_expire,
"ah_bytes_expire", KSTAT_DATA_UINT64);
/* IP-specific drop statistics. */
kstat_named_init(&ipss->ipsec_ip_drop_types->ipds_ip_ipsec_not_loaded,
"ip_ipsec_not_loaded", KSTAT_DATA_UINT64);
kstat_install(ipss->ipsec_ip_drop_kstat);
}
