[Orca-users] Re: no stats for ge0

James Kanyok james.kanyok at lmco.com
Thu May 24 07:21:11 PDT 2001


I had this same problem.  I narrowed it down to a problem with the SEToolkit.  I worked with Richard Pettit of Quest Software and he came up with a fix last week for the kstat.se file. 

To see if this is the same problem do a "netstat -i"  which should show correct stats.  Then do "se net.se" from the SEtoolkit.  If the stats are zero, you are seeing the same problem I was.

Don't know if he officially has put the fix out but here it is.

Jamie

------------------------------------------------------------------------
Subject: Re: [orca-users] Re: no stats for ge0
References: <OF0112EACE.9826305B-ON86256A55.00153E55 at f...>
Content-Type: text/plain; charset=us-ascii
Content-Transfer-Encoding: 7bit
From: Blair Zajac <blair at g...>

Than its an SE or orcallator.se issue.  I don't have a ge card, so I
won't be able to help.  An email to the SE mailing list at

se-feedback at s...

may be appropriate.

Regards,
Blair

karl.rossing at f... wrote:
>
> The columns are there, but all the entries are set to 0
>
> Karl
>
> Blair Zajac <blair at g...>
> 05/22/2001 05:44 PM
> Please respond to orca-users
>
>         To:     orca-users at yahoogroups.com
>         cc:
>         Subject:        Re: [orca-users] Re: no stats for ge0
>
> You'll have to check the output percol-* files.  Use the
> orcallator_column.pl script to check the files to see if
> there's any data there.  You can run it like
>
> zcat percol-2001.... | orcallator_column -c ge0
>
> and see what's there.  If the data is there, then its an
> orcallator.cfg issue, otherwise its a SE/orcallator issue.
>
> Regards,
> Blair
>
> karl.rossing at f... wrote:
> >
> > I'm running orca0.27b1 with setoolkit 3.2 and i'm still not getting
> > any
> > ge0 stats.
> >
> > Could it be that the setoolkit is not logging my gigabit info?
> >
> > Karl Rossing
> > 05/07/2001 10:55 AM
> >
> >         To:     orca-users at yahoogroups.com
> >         cc:
> >         Subject:        no stats for ge0
> >
> > Hi,
> >
> > I don't seem to be getting any stats for ge0 or hme0. The graphs
> come
> > up
> > blank.
> >
> > I'm using setoolkit 3.2. I understand from looking through the
> > archives
> > that  se 3.1 needed 2 small "patches" to get it to log ge0 stats.
> I'm
> > guessing that version 3.2 does not need the patch.
> >
> > Everything else seems to work fine.
> >
> > Karl
> >
> >                    Yahoo! Groups Sponsor
> > [Yahoo! Website Services- Click Here!]
> > Yahoo! Website Services- Click Here!
> >
> >
>
> http://docs.yahoo.com/info/terms/
>
>                    Yahoo! Groups Sponsor
> [Yahoo! Website Services- Click Here!]
> Yahoo! Website Services- Click Here!
>
>
-------------- next part --------------
//
//   Copyright 1998-1999 Richard Pettit, All Rights Reserved
//

/*
 * Copyright (c) 1994 by Sun Microsystems, Inc.
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*        All Rights Reserved   */

/*      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T     */
/*      The copyright notice above does not evidence any        */
/*      actual or intended publication of such source code.     */

/*
 * +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 *              PROPRIETARY NOTICE (Combined)
 *
 * This source code is unpublished proprietary information
 * constituting, or derived under license from AT&T's UNIX(r) System V.
 * In addition, portions of such source code were derived from Berkeley
 * 4.3 BSD under license from the Regents of the University of
 * California.
 *
 *
 *
 *              Copyright Notice
 *
 * Notice of copyright on this source code product does not indicate
 * publication.
 *
 *      (c) 1986,1987,1988,1989  Sun Microsystems, Inc
 *      (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
 *              All rights reserved.
 *
 */

#ifndef _KSTAT_SE_
#define _KSTAT_SE_

// for SYS_NMLN
#include <utsname.se>

/* These are the explicit declarations of kstat structure types that "se"  *
 * knows about.                                                            *
 *                                                                         *
 * IN ORDER TO USE THE KSTAT FEATURES OF "se", THIS FILE MUST BE INCLUDED. *
 *                                                                         *
 * MODIFICATION OF THESE STRUCTURES WILL RESULT IN BOGUS RESULTS.          *
 *                                                                         *
 * Addition of new types with the "ks_" prefix is harmless.                */

#if MINOR_VERSION >= 70
# define rfs_counter_t uint64_t
#else
# define rfs_counter_t uint32_t
#endif

kstat struct "rpc_client" ks_rpc_client {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t retrans;
    rfs_counter_t badxids;
    rfs_counter_t timeouts;
    rfs_counter_t newcreds;
    rfs_counter_t badverfs;
    rfs_counter_t timers;
    rfs_counter_t nomem;
    rfs_counter_t cantsend;
};

kstat struct "rpc_server" ks_rpc_server {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t nullrecv;
    rfs_counter_t badlen;
    rfs_counter_t xdrcall;
    rfs_counter_t dupchecks;
    rfs_counter_t dupreqs;
};

kstat struct "segmap" ks_segmap {
    ulong_t fault;
    ulong_t faulta;
    ulong_t getmap;
    ulong_t get_use;
    ulong_t get_reclaim;
    ulong_t get_reuse;
    ulong_t get_unused;
    ulong_t get_nofree;
    ulong_t rel_async;
    ulong_t rel_write;
    ulong_t rel_free;
    ulong_t rel_abort;
    ulong_t rel_dontneed;
    ulong_t release;
    ulong_t pagecreate;
};

kstat struct "biostats" ks_biostats {
    uint32_t buffer_cache_lookups;
    uint32_t buffer_cache_hits;
    uint32_t new_buffer_requests;
    uint32_t waits_for_buffer_allocs;
    uint32_t buffers_locked_by_someone;
    uint32_t duplicate_buffers_found;
};

kstat struct "system_misc" ks_system_misc {
    uint32_t ncpus;
    uint32_t lbolt;
    uint32_t deficit;
    uint32_t clk_intr;
    uint32_t vac;
    uint32_t nproc;
    uint32_t avenrun_1min;
    uint32_t avenrun_5min;
    uint32_t avenrun_15min;
#if MINOR_VERSION >= 60
    uint32_t boot_time;
#endif
};

kstat struct "system_pages" ks_system_pages {
    ulong_t physmem;
    ulong_t nalloc;
    ulong_t nfree;
    ulong_t nalloc_calls;
    ulong_t nfree_calls;
    ulong_t kernelbase;
    ulong_t econtig;
    ulong_t freemem;
    ulong_t availrmem;
    ulong_t lotsfree;
    ulong_t desfree;
    ulong_t minfree;
    ulong_t fastscan;
    ulong_t slowscan;
    ulong_t nscan;
    ulong_t desscan;
    ulong_t pp_kernel;
    ulong_t pagesfree;
    ulong_t pageslocked;
    ulong_t pagesio;
    ulong_t pagestotal;
};

kstat struct "cpu_info:" ks_cpu_info {
    int     number$;
    string  name$;

    string  state;
    ulong_t state_begin;
    string  cpu_type;
    string  fpu_type;
    ulong_t clock_MHz;
};

#if MINOR_VERSION >= 60
kstat struct "segplckstat" ks_segplckstat {
    ulong_t cache_hit;
    ulong_t cache_miss;
    ulong_t active_pages;
    ulong_t cached_pages;
    ulong_t purge_count;
};

kstat struct "zero_copy" ks_streams_zero_copy {
    ulong_t mapins;
    ulong_t pageflips;
    ulong_t misses;
    ulong_t kmapcaches;
    ulong_t cowfaults;
    ulong_t disabled;
    ulong_t busyslots;
};

kstat struct "daderror:" ks_daderror {
    int    number$;
    string name$;

    uint32_t "Soft Errors";
    uint32_t "Hard Errors";
    uint32_t "Transport Errors";
    string    Model;
    string    Revision;
    string   "Serial No";
    uint64_t  Size;
    uint32_t "Media Error";
    uint32_t "Device Not Ready";
    uint32_t "No Device";
    uint32_t  Recoverable;
    uint32_t "Illegal Request";
};

kstat struct "sderr:" ks_sderr {
    int    number$;
    string name$;

    uint32_t "Soft Errors";
    uint32_t "Hard Errors";
    uint32_t "Transport Errors";
    string    Vendor;
    string    Product;
    string    Revision;
    string   "Serial No";
    uint64_t  Size;
    uint32_t "Media Error";
    uint32_t "Device Not Ready";
    uint32_t "No Device";
    uint32_t  Recoverable;
    uint32_t "Illegal Request";
    uint32_t "Predictive Failure Analysis";
};

kstat struct "*fhc" ks_fhc {
    int    number$;
    string name$;

    uint32_t csr;
    uint32_t bsr;
};

kstat struct "*address_controller" ks_address_controller {
    int    number$;
    string name$;

    uint32_t acmemctl;
    uint32_t acmemdecode0;
    uint32_t acmemdecode1;
    uint32_t acmccr;
    uint32_t accounter;
};

kstat struct "sysctrl" ks_sysctrl {
    uint32_t csr;
    uint32_t status1;
    uint32_t status2;
    uint32_t clk_freq2;
    uint32_t fan_status;
    uint32_t key_status;
    uint32_t power_status;
};

kstat struct "kmem_default_backend" ks_kmem_default_backend {
    ulong_t memory_class;
    ulong_t active_clients;
    ulong_t page_size;
    ulong_t bytes_inuse;
    ulong_t alloc_8K;
    ulong_t inuse_8K;
    ulong_t alloc_16K;
    ulong_t inuse_16K;
    ulong_t alloc_32K;
    ulong_t inuse_32K;
    ulong_t alloc_64K;
    ulong_t inuse_64K;
    ulong_t alloc_128K;
    ulong_t inuse_128K;
    ulong_t alloc_256K;
    ulong_t inuse_256K;
    ulong_t alloc_512K;
    ulong_t inuse_512K;
    ulong_t alloc_1M;
    ulong_t inuse_1M;
};
#endif // MINOR_VERSION >= 60

kstat struct "kmem_misc" ks_kmem_misc {
    ulong_t arena_size;
#if MINOR_VERSION >= 60
    ulong_t huge_size;
#endif
    ulong_t huge_alloc;
    ulong_t huge_alloc_fail;
    ulong_t perm_size;
    ulong_t perm_alloc;
    ulong_t perm_alloc_fail;
};

kstat struct "inode_cache" ks_inode_cache {
    ulong_t size;
    ulong_t maxsize;
    ulong_t hits;
    ulong_t misses;
#if MINOR_VERSION < 60
    ulong_t mallocs;
    ulong_t frees;
#else
    ulong_t "kmem allocs";
    ulong_t "kmem frees";
#endif
    ulong_t "maxsize reached";
    ulong_t "puts at frontlist";
    ulong_t "puts at backlist";
    ulong_t "queues to free";
    ulong_t scans;
#if MINOR_VERSION >= 60
    ulong_t "thread idles";
    ulong_t "lookup idles";
    ulong_t "vget idles";
    ulong_t "cache allocs";
    ulong_t "cache frees";
    ulong_t "pushes at close";
#endif
};

kstat struct "rpc_clts_client" ks_rpc_clts_client {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t retrans;
    rfs_counter_t badxids;
    rfs_counter_t timeouts;
    rfs_counter_t newcreds;
    rfs_counter_t badverfs;
    rfs_counter_t timers;
    rfs_counter_t nomem;
    rfs_counter_t cantsend;
};

kstat struct "rpc_cots_client" ks_rpc_cots_client {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t badxids;
    rfs_counter_t timeouts;
    rfs_counter_t newcreds;
    rfs_counter_t badverfs;
    rfs_counter_t timers;
    rfs_counter_t cantconn;
    rfs_counter_t nomem;
    rfs_counter_t interrupts;
};

kstat struct "rpc_clts_server" ks_rpc_clts_server {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t nullrecv;
    rfs_counter_t badlen;
    rfs_counter_t xdrcall;
    rfs_counter_t dupchecks;
    rfs_counter_t dupreqs;
};

kstat struct "rpc_cots_server" ks_rpc_cots_server {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t nullrecv;
    rfs_counter_t badlen;
    rfs_counter_t xdrcall;
    rfs_counter_t dupchecks;
    rfs_counter_t dupreqs;
};

kstat struct "rfsproccnt_v2" ks_rfs_proc_v2 {
    rfs_counter_t null;
    rfs_counter_t getattr;
    rfs_counter_t setattr;
    rfs_counter_t root;
    rfs_counter_t lookup;
    rfs_counter_t readlink;
    rfs_counter_t read;
    rfs_counter_t wrcache;
    rfs_counter_t write;
    rfs_counter_t create;
    rfs_counter_t remove;
    rfs_counter_t rename;
    rfs_counter_t link;
    rfs_counter_t symlink;
    rfs_counter_t mkdir;
    rfs_counter_t rmdir;
    rfs_counter_t readdir;
    rfs_counter_t statfs;
};

kstat struct "rfsreqcnt_v2" ks_rfs_req_v2 {
    rfs_counter_t null;
    rfs_counter_t getattr;
    rfs_counter_t setattr;
    rfs_counter_t root;
    rfs_counter_t lookup;
    rfs_counter_t readlink;
    rfs_counter_t read;
    rfs_counter_t wrcache;
    rfs_counter_t write;
    rfs_counter_t create;
    rfs_counter_t remove;
    rfs_counter_t rename;
    rfs_counter_t link;
    rfs_counter_t symlink;
    rfs_counter_t mkdir;
    rfs_counter_t rmdir;
    rfs_counter_t readdir;
    rfs_counter_t statfs;
};

kstat struct "nfs_client" ks_nfs_client {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
    rfs_counter_t clgets;
    rfs_counter_t cltoomany;
};

kstat struct "nfs_server" ks_nfs_server {
    rfs_counter_t calls;
    rfs_counter_t badcalls;
};

kstat struct "lo0" ks_loopback {
    uint32_t ipackets;
    uint32_t opackets;
};

kstat struct "aclproccnt_v2" ks_acl_proc_v2 {
    rfs_counter_t null;
    rfs_counter_t getacl;
    rfs_counter_t setacl;
    rfs_counter_t getattr;
    rfs_counter_t access;
};

kstat struct "aclreqcnt_v2" ks_acl_req_v2 {
    rfs_counter_t null;
    rfs_counter_t getacl;
    rfs_counter_t setacl;
    rfs_counter_t getattr;
    rfs_counter_t access;
};

kstat struct "rfsproccnt_v3" ks_rfs_proc_v3 {
    rfs_counter_t null;
    rfs_counter_t getattr;
    rfs_counter_t setattr;
    rfs_counter_t lookup;
    rfs_counter_t access;
    rfs_counter_t readlink;
    rfs_counter_t read;
    rfs_counter_t write;
    rfs_counter_t create;
    rfs_counter_t mkdir;
    rfs_counter_t symlink;
    rfs_counter_t mknod;
    rfs_counter_t remove;
    rfs_counter_t rmdir;
    rfs_counter_t rename;
    rfs_counter_t link;
    rfs_counter_t readdir;
#if MINOR_VERSION < 60
    rfs_counter_t "readdir+";  // becomes readdir_
#else
    rfs_counter_t readdirplus;
#endif
    rfs_counter_t fsstat;
    rfs_counter_t fsinfo;
    rfs_counter_t pathconf;
    rfs_counter_t commit;
};

kstat struct "rfsreqcnt_v3" ks_rfs_req_v3 {
    rfs_counter_t null;
    rfs_counter_t getattr;
    rfs_counter_t setattr;
    rfs_counter_t lookup;
    rfs_counter_t access;
    rfs_counter_t readlink;
    rfs_counter_t read;
    rfs_counter_t write;
    rfs_counter_t create;
    rfs_counter_t mkdir;
    rfs_counter_t symlink;
    rfs_counter_t mknod;
    rfs_counter_t remove;
    rfs_counter_t rmdir;
    rfs_counter_t rename;
    rfs_counter_t link;
    rfs_counter_t readdir;
#if MINOR_VERSION < 60
    rfs_counter_t "readdir+";  // becomes readdir_
#else
    rfs_counter_t readdirplus;
#endif
    rfs_counter_t fsstat;
    rfs_counter_t fsinfo;
    rfs_counter_t pathconf;
    rfs_counter_t commit;
};

#if MINOR_VERSION < 60
# define readdirplus readdir_
#endif

kstat struct "aclproccnt_v3" ks_acl_proc_v3 {
    rfs_counter_t null;
    rfs_counter_t getacl;
    rfs_counter_t setacl;
};

kstat struct "aclreqcnt_v3" ks_acl_req_v3 {
    rfs_counter_t null;
    rfs_counter_t getacl;
    rfs_counter_t setacl;
};

#define _KMEM \
\
"*anon_cache:*anonmap_cache:*as_cache:*cred_cache:\
*ddi_callback_cache:*file_cache:*flk_edges:\
*fnode_cache:*kmem_alloc:*kmem_bufctl_cache:\
*kmem_magazine:*kmem_slab_cache:*linkinfo_cache:\
*lm_async:*lm_client:*lm_config:*lm_sleep:\
*lm_sysid:*lm_vnode:*lm_xprt:*lwp_cache:\
*pipe_cache:*prnode_cache:*qband_cache:*queue_cache:\
*rnode_cache:*seg_cache:*seg_skiplist_cache:\
*segvn_cache:*snode_cache:*stream_head_cache:\
*streams_msg:*strevent_cache:*syncq_cache:\
*thread_cache:*sfmmu:*streams_mblk:*streams_dblk:\
*physio_buf_cache:*ufs_inode_cache:*pln:*fas:*esp:\
*process_cache:*sock_cache:*exi_cache_handle:\
*directio_buf_cache"

kstat struct _KMEM ks_cache {
    int    number$;
    string name$;

    uint32_t buf_size;
    uint32_t align;
    uint32_t chunk_size;
    uint32_t slab_size;
    uint32_t alloc;
    uint32_t alloc_fail;
    uint32_t depot_alloc;
    uint32_t depot_free;
    uint32_t depot_contention;
    uint32_t global_alloc;
#if MINOR_VERSION >= 60
    uint32_t buf_constructed;
#endif
    uint32_t buf_avail;
    uint32_t buf_total;
    uint32_t buf_max;
    uint32_t slab_create;
    uint32_t slab_destroy;
#if MINOR_VERSION >= 60
    uint32_t memory_class;
#endif
    uint32_t hash_size;
    uint32_t hash_lookup_depth;
    uint32_t hash_rescale;
    uint32_t full_magazines;
    uint32_t empty_magazines;
    uint32_t magazine_size;
    uint32_t alloc_from_cpu0;
    uint32_t free_to_cpu0;
    uint32_t buf_avail_cpu0;
    /* to and from cpuN continues for each cpu... not supported */
};

// START OF NETIF STRUCTURES

/* all of the types up to this point are KSTAT_TYPE_NAMED types.  The       *
 * ks_network type is also a named type, but refers to a class of           *
 * records instead of one specific name=value record.  The ks_interrupts    *
 * type is a KSTAT_TYPE_INTR type and the ks_disks type is a                *
 * KSTAT_TYPE_IO type.                                                      */

#if MINOR_VERSION > 60
# define HME_PATCH_IFSPEED
#endif

/* lance ethernet */
kstat struct "le:" ks_le_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t  ipackets;
    ulong_t  ierrors;
    ulong_t  opackets;
    ulong_t  oerrors;
    ulong_t  collisions;
    ulong_t  defer;
    ulong_t  framing;
    ulong_t  crc;
    ulong_t  oflo;
    ulong_t  uflo;
    ulong_t  missed;
    ulong_t  late_collisions;
    ulong_t  retry_error;
    ulong_t  nocarrier;
    ulong_t  inits;
    ulong_t  nocanput;
    ulong_t  allocbfail;
    ulong_t  rbytes;
    ulong_t  obytes;
    ulong_t  multircv;
    ulong_t  multixmt;
    ulong_t  brdcstrcv;
    ulong_t  brdcstxmt;
    ulong_t  norcvbuf;
    ulong_t  noxmtbuf;
};

/* intel ethernet */
kstat struct "ie:" ks_ie_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t defer;
    ulong_t crc;
    ulong_t oflo;
    ulong_t uflo;
    ulong_t missed;
    ulong_t late_collisions;
    ulong_t retry_error;
    ulong_t nocarrier;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
    ulong_t xmitunderrun;
    ulong_t recvoverrun;
    ulong_t align;
    ulong_t notcbs;
    ulong_t notbufs;
    ulong_t norbufs;
};

#if MINOR_VERSION > 80
# define QE_PATCH_IFSPEED
#endif

/* quad ethernet */
kstat struct "qe:" ks_qe_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t rx_collisions;
    ulong_t excess_defer;
    ulong_t framming;
    ulong_t crc;
#ifdef QE_PATCH_IFSPEED
    ulong_t ifspeed;
#else
    ulong_t drop;
#endif
    ulong_t buff;
    ulong_t oflo;
    ulong_t uflo;
    ulong_t missed;
    ulong_t tx_late_collisions;
    ulong_t retry_error;
    ulong_t nocarrier;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
    ulong_t runt;
    ulong_t jabber;
    ulong_t babble;
    ulong_t tmd_error;
    ulong_t late_error;
    ulong_t parity_error;
    ulong_t error_ack;
    ulong_t no_tmds;
    ulong_t no_tbufs;
    ulong_t no_rbufs;
    ulong_t rx_late_collisions;
#if MINOR_VERSION >= 80
    // Sean O'Neal (sean.oneill at commerceone.com) did this
    ulong_t  rbytes;
    ulong_t  obytes;
    ulong_t  multircv;
    ulong_t  multixmt;
    ulong_t  brdcstrcv;
    ulong_t  brdcstxmt;
    ulong_t  norcvbuf;
    ulong_t  noxmtbuf;
#endif
};

/* bigMAC ethernet - 100baseT */
kstat struct "be:" ks_be_network {
    int   number$;
    string name$;

    ulong_t ipackets;     /* packets received */
    ulong_t ierrors;      /* input errors */
    ulong_t opackets;     /* packets transmitted */
    ulong_t oerrors;      /* output errors */
    ulong_t collisions;   /* collisions encountered */
    char     missing1;     /* slots deferred */
    ulong_t framming;     /* framing errors */
    ulong_t crc;          /* crc errors */
    char     missing2;     /* missed/drop errors */
    ulong_t buff;         /* buff errors */
    ulong_t oflo;         /* overflow errors */
    ulong_t uflo;         /* underflow errors */
    ulong_t missed;       /* missed/dropped packets */
    ulong_t tx_late_collisions;   /* late collisions */
    ulong_t retry_error;  /* retry errors */
    ulong_t nocarrier;    /* no carrier */
    ulong_t inits;        /* initialization */
    ulong_t nocanput;     /* nocanput errors */
    ulong_t allocbfail;   /* allocb failures */
    ulong_t runt;         /* runt errors */
    ulong_t jabber;       /* jabber errors */
    ulong_t babble;       /* runt errors */
    ulong_t tmd_error;    /* tmd errors */
    ulong_t late_error;   /* late errors */
    ulong_t parity_error; /* parity errors */
    ulong_t error_ack;    /* error acks */
    ulong_t no_tmds;      /* tmd errors */
    ulong_t no_tbufs;     /* tx buf errors */
    ulong_t no_rbufs;     /* rx buf errors */
    ulong_t rx_late_collisions; /* clsn errors */
};

/* bf card */
kstat struct "bf:" ks_bf_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t tx_abort;
    ulong_t tx_uflo;
    ulong_t tx_full;
    ulong_t tx_notmds;
    ulong_t tx_notavail;
    ulong_t rx_frmerr;
    ulong_t rx_oflo;
    ulong_t rx_full;
    ulong_t rx_notavail;
    ulong_t missed;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
};

#ifdef OLD_FDDI

/* definition of pre-version-5 FDDI card.  If you're using one, run  *
 * the script with "se -DOLD_FDDI script-name". - Rich               */

kstat struct "np-nf:nf" ks_nf_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t txunderruns;
    ulong_t rxoverruns;
    ulong_t cnf_invalids;
    ulong_t norxllcbufs;
    ulong_t norxsmtbufs;
    ulong_t cannotputs;
    ulong_t bsi_iar_exci0;
    ulong_t bsi_iar_exci1;
    ulong_t bsi_iar_exci2;
};

#else

/* nf card - net fiber I guess */
kstat struct "nf:" ks_nf_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t txunderruns0;
    ulong_t txunderruns1;
    ulong_t rxoverruns;
    ulong_t cnf_invalids0;
    ulong_t cnf_invalids1;
    ulong_t norxllcbufs;
    ulong_t norxsmtbufs;
    ulong_t cannotputs;
    ulong_t allocbfail;
    ulong_t bsi_iar_exci0;
    ulong_t bsi_iar_exci1;
    ulong_t bsi_iar_exci2;
    ulong_t no_copy_reqp0;
    ulong_t no_copy_reqp1;
    ulong_t no_reqp0;
    ulong_t no_reqp1;
    ulong_t pkt_toobig0;
    ulong_t pkt_toobig1;
    ulong_t tsync_underrun;
    ulong_t bad_fc;
    ulong_t invalid_idud_ch0;
    ulong_t invalid_idud_ch1;
    ulong_t invalid_idud_ch2;
    ulong_t nf_psp_on_loan;
    ulong_t invalid_frame;
    ulong_t nf_putbq;
};

#endif /* OLD_FDDI */

/* token ring */
kstat struct "tr:" ks_tr_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t inits;
    ulong_t notmds;
    ulong_t notbufs;
    ulong_t norbufs;
    ulong_t nocanput;
    ulong_t noallocb;
    ulong_t sralloc;
    ulong_t srfree;
    ulong_t linerrors;
    ulong_t bursterrors;
    ulong_t arifcierrors;
    ulong_t lostframeerrors;
    ulong_t rxcongestion;
    ulong_t frmcopiederrors;
    ulong_t tokenerrors;
    ulong_t dmabuserrors;
};

/* standard microsystems corp (western digital) */
kstat struct "smc:" ks_smc_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t nobuffer;
    ulong_t blocked;
    ulong_t blocked2;
    ulong_t multicast;
    ulong_t xbytes;
    char     missing1;
    char     missing2;
    ulong_t rbytes;
    ulong_t crc;
    ulong_t alignment;
    ulong_t fifoover;
    ulong_t lost;
    ulong_t intrs;
    ulong_t ovw;
    ulong_t watchdog;
};

/* hme - electron */
kstat struct "hme:qfe" ks_hme_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t defer;
    ulong_t framing;
    ulong_t crc;
    ulong_t sqe;
    ulong_t code_violations;
    ulong_t len_errors;
#ifdef HME_PATCH_IFSPEED
    ulong_t ifspeed;
#else
    ulong_t drop;
#endif
    ulong_t buff;
    ulong_t oflo;
    ulong_t uflo;
    ulong_t missed;
    ulong_t tx_late_collisions;
    ulong_t retry_error;
    ulong_t first_collisions;
    ulong_t nocarrier;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
    ulong_t runt;
    ulong_t jabber;
    ulong_t babble;
    ulong_t tmd_error;
    ulong_t tx_late_error;
    ulong_t rx_late_error;
    ulong_t slv_parity_error;
    ulong_t tx_parity_error;
    ulong_t rx_parity_error;
    ulong_t slv_error_ack;
    ulong_t tx_error_ack;
    ulong_t rx_error_ack;
    ulong_t tx_tag_error;
    ulong_t rx_tag_error;
    ulong_t eop_error;
    ulong_t no_tmds;
    ulong_t no_tbufs;
    ulong_t no_rbufs;
    ulong_t rx_late_collisions;
    ulong_t rbytes;
    ulong_t obytes;
    ulong_t multircv;
    ulong_t multixmt;
    ulong_t brdcstrcv;
    ulong_t brdcstxmt;
    ulong_t norcvbuf;
    ulong_t noxmtbuf;
};

/* SAHI ATM */
kstat struct "sa:" ks_sa_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
    ulong_t badcrc;
    ulong_t rxoverflow;
    ulong_t interrupts;
    ulong_t outofrbuf;
    ulong_t outoftbuf;
    ulong_t vc_noreceiver;
    ulong_t bufdrop;
};

// ieef: Intel ether-express flash
//       3com 3c503, 3com etherlink 3 (elx)
// also novell card - x86
// also Compaq NetFlex 10Base-T
// also Intel D100 Pro-B
//
// Note: "el" aka 3c503 (8 bit *ANCIENT* card) has been deleted
//       see ks_el_network (Fore) below

kstat struct "ieef:elx:pcelx:nei:cnft:iprb" ks_ieef_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t opackets;
    ulong_t ipackets;
    ulong_t oerrors;
    ulong_t ierrors;
    ulong_t collisions;
    ulong_t obytes;
    ulong_t rbytes;
    long    multixmt;
    long    multircv;
    long    brdcstxmt;
    long    brdcstrcv;
    long    blocked;
    ulong_t excollisions;
    ulong_t defer;
    ulong_t framing;
    ulong_t crc;
    ulong_t oflo;
    ulong_t uflo;
    ulong_t SYM_short;
    ulong_t missed;
    ulong_t late_collisions;
    ulong_t nocarrier;
    long    noxmtbuf;
    long    norcvbuf;
    long    intr;
    long    xmtretry;
};
#define ks_elx_network   ks_ieef_network
#define ks_pcelx_network ks_ieef_network
#define ks_nei_network   ks_ieef_network
#define ks_cnft_network  ks_ieef_network
#define ks_iprb_network  ks_ieef_network

// 3com 3c90x XL 10 and 10/100
kstat struct "elxl:" ks_elxl_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint32_t opackets;
    uint32_t ipackets;
    uint32_t oerrors;
    uint32_t ierrors;
    uint32_t collisions;
    uint32_t obytes;
    uint32_t rbytes;
    uint32_t multixmt;
    uint32_t multircv;
    uint32_t brdcstxmt;
    uint32_t brdcstrcv;
    uint32_t unknowns;
    uint32_t blocked;
    uint32_t ex_collisions;
    uint32_t defer_xmts;
    uint32_t align_errors;
    uint32_t fcs_errors;
    uint32_t oflo;
    uint32_t uflo;
    uint32_t runt_errors;
    uint32_t missed;
    uint32_t tx_late_collisions;
    uint32_t carrier_errors;
    uint32_t noxmtbuf;
    uint32_t norcvbuf;
    uint32_t xmt_badinterp;
    uint32_t rcv_badinterp;
    uint32_t intr;
    uint32_t xmtretry;
    uint64_t opackets64;
    uint64_t ipackets64;
    uint64_t obytes64;
    uint64_t rbytes64;
    uint64_t ifspeed;
    string   duplex;
    string   media;
    string   promisc;
    uint32_t first_collisions;
    uint32_t multi_collisions;
    uint32_t sqe_errors;
    uint32_t macxmt_errors;
    uint32_t toolong_errors;
    uint32_t macrcv_errors;
};

// Fore ATM cards
kstat struct "el:fa:qaa" ks_el_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    // there *must* be more members than this, right?
};

/* fddi/cddi card */
kstat struct "fddi:" ks_fddi_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t ioctets;
    ulong_t ooctets;
    ulong_t inits;
    ulong_t nocanput;
    ulong_t allocbfail;
    ulong_t interrupts;
    ulong_t ringup;
    ulong_t ringups;
    ulong_t ringdowns;
    ulong_t cLOANS;
    ulong_t tLOANS;
    ulong_t mLOANS;
    ulong_t burst;
    ulong_t aerr;
    ulong_t qerr;
    ulong_t cstyerr;
    ulong_t rsrcerr;
    ulong_t giants;
    ulong_t runts;
    ulong_t finvalid;
    ulong_t fabort;
    ulong_t fseac_e;
    ulong_t fsfrmerr;
    ulong_t txringfull;
    ulong_t npalive;
    ulong_t diag_tests;
    ulong_t nprxhangs;
    ulong_t npresets;
    ulong_t ga_rev;
    ulong_t nfddi2txbufs;
    ulong_t nfddi2rxbufs;
    ulong_t fddixdonecnt;
    ulong_t fddimaxcopysz;
    ulong_t fddimaxloanlt;
};

/* IP Dialup Point-to-point */
kstat struct "ipdptp:" ks_ppp_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t nocanput;
    ulong_t allocbfail;
};

// Hey Alteon!  STOP CHANGING YOUR KSTATS!!!

#if ALTEON_VERSION < 4

/* gigabit e-net card */
kstat struct "vge:" ks_vge_network {
  int    number$;       // linear interface number
  string name$;         // name of the interface

  ulong_t   ipackets;
  ulong_t   ierrors;
  ulong_t   opackets;
  ulong_t   oerrors;
  ulong_t   collisions;
  ulong_t   dot3StatsAlignmentErrors;
  ulong_t   dot3StatsFCSErrors;
  ulong_t   dot3StatsSingleCollisionFrames;
  ulong_t   dot3StatsMultipleCollisionFram;
  ulong_t   dot3StatsSQETestErrors;
  ulong_t   dot3StatsDeferredTransmissions;
  ulong_t   dot3StatsLateCollisions;
  ulong_t   dot3StatsExcessiveCollisions;
  ulong_t   dot3StatsInternalMacTransmitEr;
  ulong_t   dot3StatsCarrierSenseErrors;
  ulong_t   dot3StatsFrameTooLongs;
  ulong_t   dot3StatsInternalMacReceiveErr;
  ulong_t   ifIndex;
  ulong_t   ifType;
  ulong_t   ifMtu;
  ulong_t   ifSpeed;
  ulong_t   ifAdminStatus;
  ulong_t   ifOperStatus;
  ulong_t   ifLastChange;
  ulong_t   ifInOctets;
  ulong_t   ifInUcastPkts;
  ulong_t   ifInNUcastPkts;
  ulong_t   ifInDiscards;
  ulong_t   ifInErrors;
  ulong_t   ifInUnknownProtos;
  ulong_t   ifOutOctets;
  ulong_t   ifOutUcastPkts;
  ulong_t   ifOutNUcastPkts;
  ulong_t   ifOutDiscards;
  ulong_t   ifOutErrors;
  ulong_t   ifOutQLen;
  string     ifPhysAddress;
  string    "ifDescr (part 1)";               // ifDescr__part_1_
  string    "ifDescr (part 2)";               // ifDescr__part_2_
  ulong_t   nicCmdsSetSendProdIndex;
  ulong_t   nicCmdsSetRecvProdIndex;
  ulong_t   nicCmdsUpdateSendRCBFlags;
  ulong_t   nicCmdsUpdateRecvRCBFlags;
  ulong_t   nicCmdsSetMulticastMode;
  ulong_t   nicCmdsClearStats;
  ulong_t   nicCmdsAddMCastAddr;
  ulong_t   nicCmdsDelMCastAddr;
  ulong_t   nicCmdsSetPromiscMode;
  ulong_t   nicCmdsSetMACAddr;
  ulong_t   nicCmdsHostState;
  ulong_t   nicCmdsUnknown;
  ulong_t   nicEventsNICFirmwareOperationa;
  ulong_t   nicEventsSetSendConsIndex;
  ulong_t   nicEventsSetRecvConsIndex;
  ulong_t   nicEventsStatsUpdated;
  ulong_t   nicEventsLinkStateChanged;
  ulong_t   nicEventsError;
  ulong_t   nicEventsMCastListUpdated;
  ulong_t   nicInterrupts;
  ulong_t   nicAvoidedInterrupts;
  ulong_t   nicEventThresholdHit;
  ulong_t   nicSendThresholdHit;
  ulong_t   nicRecvThresholdHit;
  ulong_t   nicDmaRdOverrun;
  ulong_t   nicDmaRdUnderrun;
  ulong_t   nicDmaWrOverrun;
  ulong_t   nicDmaWrUnderrun;
  ulong_t   nicDmaWrMasterAborts;
  ulong_t   nicDmaRdMasterAborts;
  ulong_t  "nicDmaWriteRingFull ";            // nicDmaWriteRingFull_
  ulong_t   nicDmaReadRingFull;
  ulong_t   nicEventRingFull;
  ulong_t   nicEventProducerRingFull;
  ulong_t   nicTxMacDescrRingFull;
  ulong_t   nicOutOfTxBufSpaceFrameRetry;
  ulong_t   nicNoMoreWrDMADescriptors;
  ulong_t   nicNoMoreRxBDs;
  ulong_t   nicRecvBDs;
  ulong_t   nicMacRxLateColls;
  ulong_t   nicMacRxLinkLostDuringPkt;
  ulong_t   nicMacRxPhyDecodeErr;
  ulong_t   nicMacRxMacAbort;
  ulong_t   nicMacRxTruncNoResources;
  ulong_t   nicMacRxDropUla;
  ulong_t   nicMacRxDropMcast;
  ulong_t   nicMacRxFlowControl;
  ulong_t   nicMacRxDropSpace;
  ulong_t   nicMacRxColls;
  ulong_t   nicMacRxTotalAttns;
  ulong_t   nicMacRxLinkAttns;
  ulong_t   nicMacRxSyncAttns;
  ulong_t   nicMacRxConfigAttns;
  ulong_t   nicMacReset;
  ulong_t  "nicMacTxCollisionHistogram[0]";  // nicMacTxCollisionHistogram_0_
  ulong_t  "nicMacTxCollisionHistogram[1]";  // nicMacTxCollisionHistogram_1_
  ulong_t  "nicMacTxCollisionHistogram[2]";  // nicMacTxCollisionHistogram_2_
  ulong_t  "nicMacTxCollisionHistogram[3]";  // nicMacTxCollisionHistogram_3_
  ulong_t  "nicMacTxCollisionHistogram[4]";  // nicMacTxCollisionHistogram_4_
  ulong_t  "nicMacTxCollisionHistogram[5]";  // nicMacTxCollisionHistogram_5_
  ulong_t  "nicMacTxCollisionHistogram[6]";  // nicMacTxCollisionHistogram_6_
  ulong_t  "nicMacTxCollisionHistogram[7]";  // nicMacTxCollisionHistogram_7_
  ulong_t  "nicMacTxCollisionHistogram[8]";  // nicMacTxCollisionHistogram_8_
  ulong_t  "nicMacTxCollisionHistogram[9]";  // nicMacTxCollisionHistogram_9_
  ulong_t  "nicMacTxCollisionHistogram[10]"; // nicMacTxCollisionHistogram_10_
  ulong_t  "nicMacTxCollisionHistogram[11]"; // nicMacTxCollisionHistogram_11_
  ulong_t  "nicMacTxCollisionHistogram[12]"; // nicMacTxCollisionHistogram_12_
  ulong_t  "nicMacTxCollisionHistogram[13]"; // nicMacTxCollisionHistogram_13_
  ulong_t  "nicMacTxCollisionHistogram[14]"; // nicMacTxCollisionHistogram_14_
  ulong_t   nicMacTxTotalAttns;
};

#endif

// this will probably change to == 4 and then == 5 and then ...

#if ALTEON_VERSION >= 4
kstat struct "vge:" ks_vge_network {
  int    number$;       // linear interface number
  string name$;         // name of the interface

  ulong_t  ipackets;
  ulong_t  ierrors;
  ulong_t  opackets;
  ulong_t  oerrors;
  ulong_t  collisions;
  ulong_t  defer;
  ulong_t  dot3StatsAlignmentErrors;
  ulong_t  dot3StatsFCSErrors;
  ulong_t  dot3StatsSingleCollisionFrames;
  ulong_t  dot3StatsMultipleCollisionFram;
  ulong_t  dot3StatsSQETestErrors;
  ulong_t  dot3StatsDeferredTransmissions;
  ulong_t  dot3StatsLateCollisions;
  ulong_t  dot3StatsExcessiveCollisions;
  ulong_t  dot3StatsInternalMacTransmitEr;
  ulong_t  dot3StatsCarrierSenseErrors;
  ulong_t  dot3StatsFrameTooLongs;
  ulong_t  dot3StatsInternalMacReceiveErr;
  ulong_t  ifIndex;
  ulong_t  ifType;
  ulong_t  ifMtu;
  ulong_t  ifSpeed;
  ulong_t  ifAdminStatus;
  ulong_t  ifOperStatus;
  ulong_t  ifLastChange;
  uint64_t  ifHCInOctets;
  uint64_t  ifHCInUcastPkts;
  uint64_t  ifHCInMulticastPkts;
  uint64_t  ifHCInBroadcastPkts;
  ulong_t  ifInDiscards;
  ulong_t  ifInErrors;
  ulong_t  ifInUnknownProtos;
  uint64_t  ifHCOutOctets;
  uint64_t  ifHCOutUcastPkts;
  uint64_t  ifHCOutMulticastPkts;
  uint64_t  ifHCOutBroadcastPkts;
  ulong_t  ifOutDiscards;
  ulong_t  ifOutErrors;
  ulong_t  ifOutQLen;
  string    ifPhysAddress;
  string   "ifDescr (part 1)";               // ifDescr__part_1_
  string   "ifDescr (part 2)";               // ifDescr__part_2_
  ulong_t  ifLinkUpDownTrapEnable;
  ulong_t  ifHighSpeed;
  ulong_t  ifPromiscuousMode;
  ulong_t  ifConnectorPresent;
  ulong_t  nicCmdsSetSendProdIndex;
  ulong_t  nicCmdsSetRecvProdIndex;
  ulong_t  nicCmdsSetRecvJumboProdIndex;
  ulong_t  nicCmdsUpdateSendRCBFlags;
  ulong_t  nicCmdsUpdateRecvRCBFlags;
  ulong_t  nicCmdsAddMCastAddr;
  ulong_t  nicCmdsDelMCastAddr;
  ulong_t  nicCmdsSetMulticastMode;
  ulong_t  nicCmdsClearStats;
  ulong_t  nicCmdsSetPromiscMode;
  ulong_t  nicCmdsSetMACAddr;
  ulong_t  nicCmdsHostState;
  ulong_t  nicCmdsFdrFiltering;
  ulong_t  nicCmdsUnknown;
  ulong_t  nicEventsNICFirmwareOperationa;
  ulong_t  nicEventsSetSendConsIndex;
  ulong_t  nicEventsSetRecvConsIndex;
  ulong_t  nicEventsStatsUpdated;
  ulong_t  nicEventsLinkStateChanged;
  ulong_t  nicEventsError;
  ulong_t  nicEventsMCastListUpdated;
  ulong_t  nicInterrupts;
  ulong_t  nicAvoidedInterrupts;
  ulong_t  nicEventThresholdHit;
  ulong_t  nicSendThresholdHit;
  ulong_t  nicRecvThresholdHit;
  ulong_t  nicDmaRdOverrun;
  ulong_t  nicDmaRdUnderrun;
  ulong_t  nicDmaWrOverrun;
  ulong_t  nicDmaWrUnderrun;
  ulong_t  nicDmaWrMasterAborts;
  ulong_t  nicDmaRdMasterAborts;
  ulong_t "nicDmaWriteRingFull ";         // nicDmaWriteRingFull_
  ulong_t  nicDmaReadRingFull;
  ulong_t  nicEventRingFull;
  ulong_t  nicEventProducerRingFull;
  ulong_t  nicTxMacDescrRingFull;
  ulong_t  nicOutOfTxBufSpaceFrameRetry;
  ulong_t  nicNoMoreWrDMADescriptors;
  ulong_t  nicNoMoreRxBDs;
  ulong_t  nicNoSpaceInReturnRing;
  ulong_t  nicRecvBDs;
  ulong_t  nicJumboRecvBDs;
  ulong_t  nicTotalRecvBDs;
  ulong_t  nicJumboSpillOver;
  ulong_t  nicSbusHangCleared;
  ulong_t  nicMacRxLateColls;
  ulong_t  nicMacRxLinkLostDuringPkt;
  ulong_t  nicMacRxPhyDecodeErr;
  ulong_t  nicMacRxMacAbort;
  ulong_t  nicMacRxTruncNoResources;
  ulong_t  nicMacRxDropUla;
  ulong_t  nicMacRxDropMcast;
  ulong_t  nicMacRxFlowControl;
  ulong_t  nicMacRxDropSpace;
  ulong_t  nicMacRxColls;
  ulong_t  nicMacRxTotalAttns;
  ulong_t  nicMacRxLinkAttns;
  ulong_t  nicMacRxSyncAttns;
  ulong_t  nicMacRxConfigAttns;
  ulong_t  nicMacReset;
  ulong_t  nicMacRxBufDescrAttns;
  ulong_t  nicMacRxBufAttns;
  ulong_t  nicMacRxZeroFrameCleanup;
  ulong_t  nicMacRxOneFrameCleanup;
  ulong_t  nicMacRxMultipleFrameCleanup;
  ulong_t  nicMacRxTimerCleanup;
  ulong_t  nicMacRxDmaCleanup;
  ulong_t "nicMacTxCollisionHistogram[0]";  // nicMacTxCollisionHistogram_0_
  ulong_t "nicMacTxCollisionHistogram[1]";  // nicMacTxCollisionHistogram_1_
  ulong_t "nicMacTxCollisionHistogram[2]";  // nicMacTxCollisionHistogram_2_
  ulong_t "nicMacTxCollisionHistogram[3]";  // nicMacTxCollisionHistogram_3_
  ulong_t "nicMacTxCollisionHistogram[4]";  // nicMacTxCollisionHistogram_4_
  ulong_t "nicMacTxCollisionHistogram[5]";  // nicMacTxCollisionHistogram_5_
  ulong_t "nicMacTxCollisionHistogram[6]";  // nicMacTxCollisionHistogram_6_
  ulong_t "nicMacTxCollisionHistogram[7]";  // nicMacTxCollisionHistogram_7_
  ulong_t "nicMacTxCollisionHistogram[8]";  // nicMacTxCollisionHistogram_8_
  ulong_t "nicMacTxCollisionHistogram[9]";  // nicMacTxCollisionHistogram_9_
  ulong_t "nicMacTxCollisionHistogram[10]"; // nicMacTxCollisionHistogram_10_
  ulong_t "nicMacTxCollisionHistogram[11]"; // nicMacTxCollisionHistogram_11_
  ulong_t "nicMacTxCollisionHistogram[12]"; // nicMacTxCollisionHistogram_12_
  ulong_t "nicMacTxCollisionHistogram[13]"; // nicMacTxCollisionHistogram_13_
  ulong_t "nicMacTxCollisionHistogram[14]"; // nicMacTxCollisionHistogram_14_
  ulong_t  nicMacTxTotalAttns;
};
#endif

/* ATM / ELane - vjamet */
kstat struct "lane:" ks_lane_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t nocanput;
    ulong_t allocbfail;
};

/* ftSPARC net interface */
kstat struct "FTnet:" ks_ft_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    ulong_t ipackets;
    ulong_t ierrors;
    ulong_t opackets;
    ulong_t oerrors;
    ulong_t collisions;
    ulong_t no_tx_bufs;
    ulong_t no_rx_bufs;
    ulong_t allocb_fails;
    ulong_t nocanputs;
};

// Xircom PE2/3 - added by Paul van der Zwan <paulz at Holland.Sun.COM>
kstat struct "pe:" ks_pe_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint32_t opackets;
    uint32_t ipackets;
    uint32_t oerrors;
    uint32_t ierrors;
    uint32_t collisions;
    uint32_t obytes;
    uint32_t rbytes;
    uint32_t multixmt;
    uint32_t multircv;
    uint32_t brdcstxmt;
    uint32_t brdcstrcv;
    uint32_t unknowns;
    uint32_t blocked;
    uint32_t ex_collisions;
    uint32_t defer_xmts;
    uint32_t align_errors;
    uint32_t fcs_errors;
    uint32_t oflo;
    uint32_t uflo;
    uint32_t runt_errors;
    uint32_t missed;
    uint32_t tx_late_collisions;
    uint32_t carrier_errors;
    uint32_t noxmtbuf;
    uint32_t norcvbuf;
    uint32_t xmt_badinterp;
    uint32_t rcv_badinterp;
    uint32_t intr;
    uint32_t xmtretry;
    uint64_t opackets64;
    uint64_t ipackets64;
    uint64_t obytes64;
    uint64_t rbytes64;
    uint64_t ifspeed;
};

/* SAHI-2 ATM - jan */
kstat struct "ba:" ks_ba_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint32_t inits;
    uint32_t nocanput;
    uint32_t allocbfail;
    uint32_t badcrc;
    uint32_t rxoverflow;
    uint32_t interrupts;
    uint32_t outofrbuf;
    uint32_t outoftbuf;
    uint32_t vc_noreceiver;
    uint64_t ifspeed;
    uint64_t rbytes64;
    uint64_t obytes64;
    uint32_t rbytes;
    uint32_t obytes;
    uint64_t ipackets64;
    uint64_t opackets64;
    uint32_t ipackets;
    uint32_t opackets;
    uint32_t multircv;
    uint32_t brdcstrcv;
    uint32_t multixmt;
    uint32_t brdcstxmt;
    uint32_t norcvbuf;
    uint32_t ierrors;
    uint32_t unknowns;
    uint32_t noxmtbuf;
    uint32_t oerrors;
    uint32_t collisions;
};

kstat struct "ge:" ks_ge_network {
    int number$;
    string name$;

    ulong_t  ipackets;
    ulong_t  ierrors;
    ulong_t  opackets;
    ulong_t  oerrors;
    ulong_t  collisions;
    ulong_t  ifspeed;
    string   missing1;
    ulong_t  rbytes;
    ulong_t  obytes;
    ulong_t  multircv;
    ulong_t  multixmt;
    ulong_t  brdcstrcv;
    ulong_t  brdcstxmt;
    ulong_t  norcvbuf;
    ulong_t  noxmtbuf;
    ulong_t  inits;
    ulong_t  mac_mode;
    ulong_t  xmit_dma_mode;
    ulong_t  rcv_dma_mode;
    ulong_t  nocarrier;
    ulong_t  nocanput;
    ulong_t  allocbfail;
    ulong_t  pause_rcv_cnt;
    ulong_t  pause_on_cnt;
    ulong_t  pause_off_cnt;
    ulong_t  pause_time_cnt;
    ulong_t  txmac_urun;
    ulong_t  txmac_maxpkt_err;
    ulong_t  excessive_coll;
    ulong_t  late_coll;
    ulong_t  first_coll;
    ulong_t  defer_timer_exp;
    ulong_t  peak_attempt_cnt;
    ulong_t  jabber;
    ulong_t  no_tmds;
    ulong_t  txinits;
    ulong_t  drop;
    ulong_t  rxinits;
    ulong_t  no_free_rx_desc;
    ulong_t  rx_overflow;
    ulong_t  rx_hang;
    ulong_t  rxtag_error;
    ulong_t  rx_align_err;
    ulong_t  rx_crc_err;
    ulong_t  rx_length_err;
    ulong_t  rx_code_viol_err;
    ulong_t  pci_badack;
    ulong_t  pci_dtrto;
    ulong_t  pci_data_parity_err;
    ulong_t  pci_signal_target_abort;
    ulong_t  pci_rcvd_target_abort;
    ulong_t  pci_rcvd_master_abort;
    ulong_t  pci_signal_system_err;
    ulong_t  pci_det_parity_err;
    ulong_t  pci_bus_speed;
    ulong_t  pci_bus_width;
    ulong_t  tx_late_error;
    ulong_t  rx_late_error;
    ulong_t  slv_parity_error;
    ulong_t  tx_parity_error;
    ulong_t  rx_parity_error;
    ulong_t  slv_error_ack;
    ulong_t  tx_error_ack;
    ulong_t  rx_error_ack;
    uint64_t ipackets64;
    uint64_t opackets64;
    uint64_t rbytes64;
    uint64_t obytes64;
    ulong_t  align_errors;
    ulong_t  fcs_errors;
    string   missing2;
    ulong_t  sqe_errors;
    ulong_t  defer_xmts;
    ulong_t  ex_collisions;
    ulong_t  macxmt_errors;
    ulong_t  carrier_errors;
    ulong_t  toolong_errors;
    ulong_t  macrcv_errors;
    ulong_t  ge_csumerr;
    ulong_t  ge_queue_cnt;
    ulong_t  ge_queue_full_cnt;
};

// Digital NIC - added by pel
kstat struct "dnet:" ks_dnet_network {
    int number$;
    string name$;

    uint32_t opackets;
    uint32_t ipackets;
    uint32_t oerrors;
    uint32_t ierrors;
    uint32_t collisions;
    uint32_t obytes;
    uint32_t rbytes;
    uint32_t multixmt;
    uint32_t multircv;
    uint32_t brdcstxmt;
    uint32_t brdcstrcv;
    uint32_t unknowns;
    uint32_t blocked;
    uint32_t ex_collisions;
    uint32_t defer_xmts;
    uint32_t align_errors;
    uint32_t fcs_errors;
    uint32_t oflo;
    uint32_t uflo;
    uint32_t runt_errors;
    uint32_t missed;
    uint32_t tx_late_collisions;
    uint32_t carrier_errors;
    uint32_t noxmtbuf;
    uint32_t norcvbuf;
    uint32_t xmt_badinterp;
    uint32_t rcv_badinterp;
    uint32_t intr;
    uint32_t xmtretry;
    uint64_t opackets64;
    uint64_t ipackets64;
    uint64_t obytes64;
    uint64_t rbytes64;
    uint64_t ifspeed;
    string   missing1;
    string   media;
    string   promisc;
    string   missing2;
    string   missing3;
    string   missing4;
    string   missing5;
    string   missing6;
    string   missing7;
};

// pci fddi
kstat struct "pf:" ks_pf_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint32_t ipackets;
    uint32_t ierrors;
    uint32_t opackets;
    uint32_t oerrors;
    uint32_t outsmt;
    uint32_t macstate;
    uint32_t llcstate;
    uint32_t notxbufs;
    uint32_t notmds;
    uint32_t notxsmtbufs;
    uint32_t txsetuperr;
    uint32_t insmt;
    uint32_t indiscards;
    uint32_t norxbufs;
    uint32_t rxpfail;
    uint32_t rxefail;
    uint32_t rxdupfail;
    uint32_t nocanputs;
    uint32_t badfc;
    uint32_t intrs;
    uint32_t reset;
};

kstat struct "dmfe:" ks_dmfe_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint32_t opackets;
    uint32_t ipackets;
    uint64_t oerrors;
    uint64_t ierrors;
    uint64_t collisions;
    uint32_t obytes;
    uint32_t rbytes;
    uint64_t multixmt;
    uint64_t multircv;
    uint64_t brdcstxmt;
    uint64_t brdcstrcv;
    uint64_t unknowns;
    uint64_t blocked;
    uint64_t ex_collisions;
    uint64_t defer_xmts;
    uint64_t align_errors;
    uint64_t fcs_errors;
    uint64_t oflo;
    uint64_t uflo;
    uint64_t runt_errors;
    uint64_t missed;
    uint64_t tx_late_collisions;
    uint64_t carrier_errors;
    uint64_t noxmtbuf;
    uint64_t norcvbuf;
    uint32_t xmt_badinterp;
    uint32_t rcv_badinterp;
    uint64_t intr;
    uint64_t xmtretry;
    uint64_t opackets64;
    uint64_t ipackets64;
    uint64_t obytes64;
    uint64_t rbytes64;
    uint64_t ifspeed;
};

/* eri - Added CDT for UltraSparc III systems */
kstat struct "eri:" ks_eri_network {
    int    number$;       /* linear interface number */
    string name$;         /* name of the interface   */

    uint64_t ipackets;
    uint64_t ierrors;
    uint64_t opackets;
    uint64_t oerrors;
    uint64_t collisions;
    uint64_t ifspeed;
    uint64_t rbytes;
    uint64_t obytes;
    uint64_t multircv;
    uint64_t multixmt;
    uint64_t brdcstrcv;
    uint64_t brdcstxmt;
    uint64_t norcvbuf;
    uint64_t noxmtbuf;
    uint64_t inits;
    uint64_t rx_inits;
    uint64_t tx_inits;
    uint64_t nocarrier;
    uint64_t nocanput;
    uint64_t allocbfail;
    uint64_t drop;
    uint64_t pasue_rcv_cnt;
    uint64_t pasue_on_cnt;
    uint64_t pasue_off_cnt;
    uint64_t pasue_time_cnt;
    uint64_t txmac_urun;
    uint64_t txmac_maxpkt_err;
    uint64_t excessive_coll;
    uint64_t late_coll;
    uint64_t first_coll;
    uint64_t defer_timer_exp;
    uint64_t peak_attempt_cnt;
    uint64_t jabber;
    uint64_t no_tmds;
    uint64_t tx_hang;
    uint64_t rx_corr;
    uint64_t no_free_rx_desc;
    uint64_t rx_overflow;
    uint64_t rx_hang;
    uint64_t rx_align_err;
    uint64_t rx_crc_err;
    uint64_t rx_length_err;
    uint64_t rx_code_viol_err;
    uint64_t bad_pkts;
    uint64_t runt;
    uint64_t toolong_pkts;
    uint64_t rxtag_error;
    uint64_t parity_error;
    uint64_t pci_error_interrupt;
    uint64_t unknown_fatal;
    uint64_t pci_data_parity_err;
    uint64_t pci_signal_target_abort;
    uint64_t pci_rcvd_target_abort;
    uint64_t pci_rcvd_master_abort;
    uint64_t pci_signal_system_err;
    uint64_t pci_det_parity_err;
    uint64_t ipackets64;
    uint64_t opackets64;
    uint64_t rbytes64;
    uint64_t obytes64;
    uint64_t pmcap;
};

/* Sysconnekt gigabit e-net card */
kstat struct "skge:" ks_skge_network {
  int    number$;	/* linear interface number */
  string name$;		/* name of the interface   */

  uint_t  ipackets;
  uint_t  opackets;
  uint_t  ierrors;
  uint_t  oerrors;
  uint_t  collisions;
  ulong_t obytes;
  ulong_t rbytes;
  ulong_t multixmt;
  ulong_t multircv;
  ulong_t brdcstxmit;
  ulong_t brdcstrcv;
  ulong_t blocked;
  ulong_t noxmtbuf;
  ulong_t norcvbuf;
  ulong_t xmtretry;
  ulong_t intr;
  ulong_t nocarrier;
  ulong_t defer;
  ulong_t framing;
  ulong_t crc;
  ulong_t oflo;
  ulong_t uflo;
  ulong_t missed;
  ulong_t rxtoolong;
  ulong_t inrangeerr;
  ulong_t late_collisions;
  ulong_t SYM_short;
  ulong_t excollisions;
  ulong_t ifspeed;
  ulong_t conmode;
};

// END OF NETIF STRUCTURES

struct ks_interrupts {
    int    number$;       /* linear device number */
    string name$;         /* name of the device   */

    uint32_t  hard;
    uint32_t  soft;       /* these members are arranged in order according  */
    uint32_t  watchdog;   /* to the definitions of the KSTAT_INTR values in */
    uint32_t  spurious;   /* sys/ksth.  Changing the order of these      */
    uint32_t  multsvc;    /* members will have silly results.               */
};

struct ks_disks {
    int       number$;    /* linear disk number */
    string    name$;      /* name of the device */

    uint64_t  nread;
    uint64_t  nwritten;   /* these members are arranged in the same order  */
    uint32_t  reads;      /* as they appear in the kstat_io_t structure in */
    uint32_t  writes;     /* sys/kstat.h.  Changing the order of these     */
    int64_t   wtime;      /* members will have silly results.              */
    int64_t   wlentime;
    int64_t   wlastupdate;
    int64_t   rtime;
    int64_t   rlentime;
    int64_t   rlastupdate;
    uint32_t  wcnt;
    uint32_t  rcnt;
};

/* begin KSTAT_TYPE_RAW types */

struct ks_sysinfo {  /* (update frequency) update action     */
    uint32_t updates;   /* (1 sec) ++                           */
    uint32_t runque;    /* (1 sec) += num runnable procs        */
    uint32_t runocc;    /* (1 sec) ++ if num runnable procs > 0 */
    uint32_t swpque;    /* (1 sec) += num swapped procs         */
    uint32_t swpocc;    /* (1 sec) ++ if num swapped procs > 0  */
    uint32_t waiting;   /* (1 sec) += jobs waiting for I/O      */

};

struct ks_vminfo {
    uint64_t freemem;     /* (1 sec) += freemem in pages          */
    uint64_t swap_resv;   /* (1 sec) += reserved swap in pages    */
    uint64_t swap_alloc;  /* (1 sec) += allocated swap in pages   */
    uint64_t swap_avail;  /* (1 sec) += unreserved swap in pages  */
    uint64_t swap_free;   /* (1 sec) += unallocated swap in pages */
};

/* see /usr/include/sys/dnlc.h */
struct ks_ncstats {
    int32_t hits;          /* hits that we can really use */
    int32_t misses;        /* cache misses */
    int32_t enters;        /* number of enters done */
    int32_t dbl_enters;    /* number of enters tried when already cached */
    int32_t long_enter;    /* long names tried to enter */
    int32_t long_look;     /* long names tried to look up */
    int32_t move_to_front; /* entry moved to front of hash chain */
    int32_t purges;        /* number of purges of cache */
};

/* see /usr/include/sys/vmmeter.h */
struct ks_flushmeter {
    uint32_t f_ctx;        /* No. of context flushes */
    uint32_t f_segment;    /* No. of segment flushes */
    uint32_t f_page;       /* No. of complete page flushes */
    uint32_t f_partial;    /* No. of partial page flushes */
    uint32_t f_usr;        /* No. of non-supervisor flushes */
    uint32_t f_region;     /* No. of region flushes */
};

/* see /usr/include/sys/var.h */
struct ks_var {
    int32_t v_buf;          /* Nbr of I/O buffers.                  */
    int32_t v_call;         /* Nbr of callout (timeout) entries.    */
    int32_t v_proc;         /* Max nbr of processes system wide     */
    int32_t v_maxupttl;     /* Max user processes system wide       */
    int32_t v_nglobpris;    /* Nbr of global sched prios configured */
    int32_t v_maxsyspri;    /* Max global pri used by sys class.    */
    int32_t v_clist;        /* Nbr of clists allocated.             */
    int32_t v_maxup;        /* Max number of processes per user.    */
    int32_t v_hbuf;         /* Nbr of hash buffers to allocate.     */
    int32_t v_hmask;        /* Hash mask for buffers.               */
    int32_t v_pbuf;         /* Nbr of physical I/O buffers.         */
    int32_t v_sptmap;       /* Size of system virtual space         */
                            /* allocation map.                      */
    int32_t v_maxpmem;      /* The maximum physical memory to use.  */
                            /* If v_maxpmem == 0, then use all      */
                            /* available physical memory.           */
                            /* Otherwise, value is amount of mem to */
                            /* use specified in pages.              */
    int32_t v_autoup;       /* The age a delayed-write buffer must  */
                            /* be in seconds before bdflush will    */
                            /* write it out.                        */
    int32_t v_bufhwm;       /* high-water-mark of buffer cache      */
                            /* memory usage, in units of K Bytes    */
#if MINOR_VERSION < 70
    int32_t v_xsdsegs;      /* Number of XENIX shared data segs */
    int32_t v_xsdslots;     /* Number of slots in xsdtab[] per segment */
#endif
};

/* structures contained in the cpu_stat_t type.  These all have the name *
 * and number members since they're per-cpu structures.                  */

#define CPU_IDLE        0
#define CPU_USER        1
#define CPU_KERNEL      2
#define CPU_WAIT        3
#define CPU_STATES      4

#define W_IO            0
#define W_SWAP          1
#define W_PIO           2
#define W_STATES        3

/* see /usr/include/sys/sysinfo.h */
struct ks_cpu_sysinfo {
    int    number$;        /* linear cpu number */
    string name$;          /* name of the cpu */
    int    instance;       /* actual instance number from kernel   */

    uint32_t  cpu[CPU_STATES]; /* CPU utilization                     */
    uint32_t  wait[W_STATES]; /* CPU wait time breakdown              */
    uint32_t  bread;          /* physical block reads                 */
    uint32_t  bwrite;         /* physical block writes (sync+async)   */
    uint32_t  lread;          /* logical block reads                  */
    uint32_t  lwrite;         /* logical block writes                 */
    uint32_t  phread;         /* raw I/O reads                        */
    uint32_t  phwrite;        /* raw I/O writes                       */
    uint32_t  pswitch;        /* context switches                     */
    uint32_t  trap;           /* traps                                */
    uint32_t  intr;           /* device interrupts                    */
    uint32_t  syscall;        /* system calls                         */
    uint32_t  sysread;        /* read() + readv() system calls        */
    uint32_t  syswrite;       /* write() + writev() system calls      */
    uint32_t  sysfork;        /* forks                                */
    uint32_t  sysvfork;       /* vforks                               */
    uint32_t  sysexec;        /* execs                                */
    uint32_t  readch;         /* bytes read by rdwr()                 */
    uint32_t  writech;        /* bytes written by rdwr()              */
    uint32_t  rcvint;         /* XXX: UNUSED                          */
    uint32_t  xmtint;         /* XXX: UNUSED                          */
    uint32_t  mdmint;         /* XXX: UNUSED                          */
    uint32_t  rawch;          /* terminal input characters            */
    uint32_t  canch;          /* chars handled in canonical mode      */
    uint32_t  outch;          /* terminal output characters           */
    uint32_t  msg;            /* msg count (msgrcv()+msgsnd() calls)  */
    uint32_t  sema;           /* semaphore ops count (semop() calls)  */
    uint32_t  namei;          /* pathname lookups                     */
    uint32_t  ufsiget;        /* ufs_iget() calls                     */
    uint32_t  ufsdirblk;      /* directory blocks read                */
    uint32_t  ufsipage;       /* inodes taken with attached pages     */
    uint32_t  ufsinopage;     /* inodes taked with no attached pages  */
    uint32_t  inodeovf;       /* inode table overflows                */
    uint32_t  fileovf;        /* file table overflows                 */
    uint32_t  procovf;        /* proc table overflows                 */
    uint32_t  intrthread;     /* interrupts as threads (below clock)  */
    uint32_t  intrblk;        /* intrs blkd/prempted/released (swtch) */
    uint32_t  idlethread;     /* times idle thread scheduled          */
    uint32_t  inv_swtch;      /* involuntary context switches         */
    uint32_t  nthreads;       /* thread_create()s                     */
    uint32_t  cpumigrate;     /* cpu migrations by threads            */
    uint32_t  xcalls;         /* xcalls to other cpus                 */
    uint32_t  mutex_adenters; /* failed mutex enters (adaptive)       */
    uint32_t  rw_rdfails;     /* rw reader failures                   */
    uint32_t  rw_wrfails;     /* rw writer failures                   */
    uint32_t  modload;        /* times loadable module loaded         */
    uint32_t  modunload;      /* times loadable module unloaded       */
    uint32_t  bawrite;        /* physical block writes (async)        */
/* Following  are gathered only under #ifdef STATISTICS in source        */
    uint32_t  rw_enters;      /* tries to acquire rw lock             */
    uint32_t  win_uo_cnt;     /* reg window user overflows            */
    uint32_t  win_uu_cnt;     /* reg window user underflows           */
    uint32_t  win_so_cnt;     /* reg window system overflows          */
    uint32_t  win_su_cnt;     /* reg window system underflows         */
    uint32_t  win_suo_cnt;    /* reg window system user overflows     */
};

struct ks_cpu_syswait {
    int     number$;        /* linear cpu number */
    string  name$;          /* name of the cpu   */
    int     instance;       /* actual instance number from kernel   */

    int32_t iowait;         /* procs waiting for block I/O          */
    int32_t swap;           /* XXX: UNUSED                          */
    int32_t physio;         /* XXX: UNUSED                          */
};

struct ks_cpu_vminfo {
    int    number$;        /* linear cpu number */
    string name$;          /* name of the cpu   */
    int    instance;       /* actual instance number from kernel   */

    uint32_t   pgrec;          /* page reclaims (includes pageout)     */
    uint32_t   pgfrec;         /* page reclaims from free list         */
    uint32_t   pgin;           /* pageins                              */
    uint32_t   pgpgin;         /* pages paged in                       */
    uint32_t   pgout;          /* pageouts                             */
    uint32_t   pgpgout;        /* pages paged out                      */
    uint32_t   swapin;         /* swapins                              */
    uint32_t   pgswapin;       /* pages swapped in                     */
    uint32_t   swapout;        /* swapouts                             */
    uint32_t   pgswapout;      /* pages swapped out                    */
    uint32_t   zfod;           /* pages zero filled on demand          */
    uint32_t   dfree;          /* pages freed by daemon or auto        */
    uint32_t   scan;           /* pages examined by pageout daemon     */
    uint32_t   rev;            /* revolutions of the page daemon hand  */
    uint32_t   hat_fault;      /* minor page faults via hat_fault()    */
    uint32_t   as_fault;       /* minor page faults via as_fault()     */
    uint32_t   maj_fault;      /* major page faults                    */
    uint32_t   cow_fault;      /* copy-on-write faults                 */
    uint32_t   prot_fault;     /* protection faults                    */
    uint32_t   softlock;       /* faults due to software locking req   */
    uint32_t   kernel_asflt;   /* as_fault()s in kernel addr space     */
    uint32_t   pgrrun;         /* times pager scheduled                */
};

struct ks_cachefs {
    int    number$;
    string name$;

    string    cfs_mount_point;
    string    cfs_back_fs;
    string    cfs_cache_dir;
    string    cfs_cache_id;
    uint32_t  cfs_hits;
    uint32_t  cfs_misses;
    uint32_t  cfs_passes;
    uint32_t  cfs_fails;
    uint32_t  cfs_modifies;
    uint32_t  cfs_gc_count;
    int32_t   cfs_gc_time;
    int32_t   cfs_gc_before_atime;
    int32_t   cfs_gc_after_atime;
};

#define KNC_STRSIZE     128     // maximum length of knetconfig 

struct ks_nfs_mount {
    // the first three members are added by the interpreter

    int    number$;       // linear mount index
    string name$;         // name from kstat
    int    instance;      // mnttab::dev= & 0xFFFF

    // these are from nfs/nfs_clnt.h

    char            mik_proto[KNC_STRSIZE];
    uint32_t        mik_vers;
    uint_t          mik_flags;
    uint_t          mik_secmod;
    uint32_t        mik_curread;
    uint32_t        mik_curwrite;
    int             mik_retrans;
    uint32_t        lookup_srtt;     // These 12 members are represented
    uint32_t        lookup_deviate;  // as an array of structures in nfs_clnt.h.
    uint32_t        lookup_rtxcur;   // If I did it this way, I'd have to
    uint32_t        read_srtt;       // rewrite the kstat handling code in
    uint32_t        read_deviate;    // the interpreter.  And I don't have the
    uint32_t        read_rtxcur;     // time to do that.
    uint32_t        write_srtt;
    uint32_t        write_deviate;
    uint32_t        write_rtxcur;
    uint32_t        all_srtt;        // smoothed round trip time
    uint32_t        all_deviate;     // estimated deviation
    uint32_t        all_rtxcur;      // current backed-off retransmission
    uint32_t        mik_noresponse;
    uint32_t        mik_failover;
    uint32_t        mik_remap;
    char            mik_curserver[SYS_NMLN];
};

#endif /* _KSTAT_SE_ */


More information about the Orca-users mailing list