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); }