ioctls and trailers
[unix-history] / usr / src / sys / vax / if / if_vv.c
index e237703..c3afc2a 100644 (file)
@@ -1,39 +1,50 @@
-/*     if_vv.c 4.3     82/06/13        */
+/*     if_vv.c 4.21    83/06/12        */
+
+#include "vv.h"
 
 /*
  * Proteon 10 Meg Ring Driver.
  * This device is called "vv" because its "real name",
  * V2LNI won't work if shortened to the obvious "v2".
  * Hence the subterfuge.
 
 /*
  * Proteon 10 Meg Ring Driver.
  * This device is called "vv" because its "real name",
  * V2LNI won't work if shortened to the obvious "v2".
  * Hence the subterfuge.
+ *
  */
  */
+#include "../machine/pte.h"
+
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/mbuf.h"
 #include "../h/param.h"
 #include "../h/systm.h"
 #include "../h/mbuf.h"
-#include "../h/pte.h"
 #include "../h/buf.h"
 #include "../h/protosw.h"
 #include "../h/socket.h"
 #include "../h/buf.h"
 #include "../h/protosw.h"
 #include "../h/socket.h"
-#include "../h/ubareg.h"
-#include "../h/ubavar.h"
-#include "../h/cpu.h"
-#include "../h/mtpr.h"
 #include "../h/vmmac.h"
 #include "../h/vmmac.h"
-#include "../net/in.h"
-#include "../net/in_systm.h"
+#include "../h/errno.h"
+#include "../h/time.h"
+#include "../h/kernel.h"
+#include "../h/ioctl.h"
+
 #include "../net/if.h"
 #include "../net/if.h"
-#include "../net/if_vv.h"
-#include "../net/if_uba.h"
-#include "../net/ip.h"
-#include "../net/ip_var.h"
+#include "../net/netisr.h"
 #include "../net/route.h"
 
 #include "../net/route.h"
 
-#include "vv.h"
+#include "../netinet/in.h"
+#include "../netinet/in_systm.h"
+#include "../netinet/ip.h"
+#include "../netinet/ip_var.h"
+
+#include "../vax/mtpr.h"
+#include "../vax/cpu.h"
+
+#include "../vaxuba/ubareg.h"
+#include "../vaxuba/ubavar.h"
+
+#include "../vaxif/if_vv.h"
+#include "../vaxif/if_uba.h"
 
 /*
  * N.B. - if WIRECENTER is defined wrong, it can well break
  * the hardware!!
  */
 
 /*
  * N.B. - if WIRECENTER is defined wrong, it can well break
  * the hardware!!
  */
-#undef AUTOIDENTIFY
 #define        WIRECENTER
 
 #ifdef WIRECENTER
 #define        WIRECENTER
 
 #ifdef WIRECENTER
 #endif
 
 #define        VVMTU   (1024+512)
 #endif
 
 #define        VVMTU   (1024+512)
+#define VVMRU  (1024+512+16)   /* space for trailer */
+
+int vv_tracehdr = 0,           /* 1 => trace headers (slowly!!) */
+    vv_tracetimeout = 1;       /* 1 => trace input error-rate limiting */
+    vv_logreaderrors = 0;      /* 1 => log all read errors */
+
+#define vvtracehdr     if (vv_tracehdr) vvprt_hdr
+#define        vvtrprintf      if (vv_tracetimeout) printf
+
+int vv_ticking = 0;            /* error flywheel is running */
+
+/*
+ * Interval in HZ - 50 msec.
+ * N.B. all times below are in units of flywheel ticks
+ */
+#define VV_FLYWHEEL            3
+#define        VV_ERRORTHRESHOLD       100     /* errors/flywheel-interval */
+#define        VV_MODE1ATTEMPTS        10      /* number mode 1 retries */
+#define        VV_MODE1DELAY           2       /* period interface is PAUSEd - 100ms */
+#define VV_MODE2DELAY          4       /* base interval host relay is off - 200ms */
+#define        VV_MAXDELAY             6400    /* max interval host relay is off - 2 minutes */
 
 int    vvprobe(), vvattach(), vvrint(), vvxint();
 struct uba_device *vvinfo[NVV];
 
 int    vvprobe(), vvattach(), vvrint(), vvxint();
 struct uba_device *vvinfo[NVV];
@@ -50,7 +82,7 @@ u_short vvstd[] = { 0 };
 struct uba_driver vvdriver =
        { vvprobe, 0, vvattach, 0, vvstd, "vv", vvinfo };
 #define        VVUNIT(x)       minor(x)
 struct uba_driver vvdriver =
        { vvprobe, 0, vvattach, 0, vvstd, "vv", vvinfo };
 #define        VVUNIT(x)       minor(x)
-int    vvinit(),vvoutput(),vvreset();
+int    vvinit(),vvioctl(),vvoutput(),vvreset();
 
 /*
  * Software status of each interface.
 
 /*
  * Software status of each interface.
@@ -67,15 +99,36 @@ int vvinit(),vvoutput(),vvreset();
 struct vv_softc {
        struct  ifnet vs_if;            /* network-visible interface */
        struct  ifuba vs_ifuba;         /* UNIBUS resources */
 struct vv_softc {
        struct  ifnet vs_if;            /* network-visible interface */
        struct  ifuba vs_ifuba;         /* UNIBUS resources */
-       short   vs_oactive;             /* is output active? */
+       short   vs_oactive;             /* is output active */
+       short   vs_iactive;             /* is input active */
        short   vs_olen;                /* length of last output */
        u_short vs_lastx;               /* last destination address */
        short   vs_olen;                /* length of last output */
        u_short vs_lastx;               /* last destination address */
-       short   vs_tries;               /* current retry count */
+       short   vs_tries;               /* transmit current retry count */
        short   vs_init;                /* number of ring inits */
        short   vs_init;                /* number of ring inits */
-       short   vs_flush;               /* number of flushed packets */
        short   vs_nottaken;            /* number of packets refused */
        short   vs_nottaken;            /* number of packets refused */
+       /* input error rate limiting state */
+       short   vs_major;               /* recovery major state */
+       short   vs_minor;               /* recovery minor state */
+       short   vs_retry;               /* recovery retry count */
+       short   vs_delayclock;          /* recovery delay clock */
+       short   vs_delayrange;          /* increasing delay interval */
+       short   vs_dropped;             /* number of packes tossed in last dt */
 } vv_softc[NVV];
 
 } vv_softc[NVV];
 
+/*
+ * States of vs_iactive.
+ */
+#define        ACTIVE  1               /* interface should post new receives */
+#define        PAUSE   0               /* interface should NOT post new receives */
+#define        OPEN    -1              /* PAUSE and open host relay */
+
+/*
+ * Recovery major states.
+ */
+#define        MODE0   0               /* everything is wonderful */
+#define        MODE1   1               /* hopefully whatever will go away */
+#define        MODE2   2               /* drastic measures - open host relay for increasing intervals */
+
 vvprobe(reg)
        caddr_t reg;
 {
 vvprobe(reg)
        caddr_t reg;
 {
@@ -83,12 +136,12 @@ vvprobe(reg)
        register struct vvreg *addr = (struct vvreg *)reg;
 
 #ifdef lint
        register struct vvreg *addr = (struct vvreg *)reg;
 
 #ifdef lint
-       br = 0; cvec = br; br = cvec;
+       br = 0; cvec = br; br = cvec; vvrint(0);
 #endif
        /* reset interface, enable, and wait till dust settles */
        addr->vvicsr = VV_RST;
        addr->vvocsr = VV_RST;
 #endif
        /* reset interface, enable, and wait till dust settles */
        addr->vvicsr = VV_RST;
        addr->vvocsr = VV_RST;
-       DELAY(100000);
+       DELAY(10000);
        /* generate interrupt by doing 1 word DMA from 0 in uba space!! */
        addr->vvocsr = VV_IEN;          /* enable interrupt */
        addr->vvoba = 0;                /* low 16 bits */
        /* generate interrupt by doing 1 word DMA from 0 in uba space!! */
        addr->vvocsr = VV_IEN;          /* enable interrupt */
        addr->vvoba = 0;                /* low 16 bits */
@@ -111,28 +164,20 @@ vvattach(ui)
        struct uba_device *ui;
 {
        register struct vv_softc *vs = &vv_softc[ui->ui_unit];
        struct uba_device *ui;
 {
        register struct vv_softc *vs = &vv_softc[ui->ui_unit];
-       register struct sockaddr_in *sin;
-COUNT(VVATTACH);
 
        vs->vs_if.if_unit = ui->ui_unit;
        vs->vs_if.if_name = "vv";
        vs->vs_if.if_mtu = VVMTU;
 
        vs->vs_if.if_unit = ui->ui_unit;
        vs->vs_if.if_name = "vv";
        vs->vs_if.if_mtu = VVMTU;
-       vs->vs_if.if_net = ui->ui_flags;
-       vs->vs_if.if_host[0] = 0;       /* this will be reset in vvinit() */
-
-       sin = (struct sockaddr_in *)&vs->vs_if.if_addr;
-       sin->sin_family = AF_INET;
-       sin->sin_addr = if_makeaddr(vs->vs_if.if_net, vs->vs_if.if_host[0]);
-
-       sin = (struct sockaddr_in *)&vs->vs_if.if_broadaddr;
-       sin->sin_family = AF_INET;
-       sin->sin_addr = if_makeaddr(vs->vs_if.if_net, VV_BROADCAST);
-       vs->vs_if.if_flags = IFF_BROADCAST;
-
        vs->vs_if.if_init = vvinit;
        vs->vs_if.if_init = vvinit;
+       vs->vs_if.if_ioctl = vvioctl;
        vs->vs_if.if_output = vvoutput;
        vs->vs_if.if_output = vvoutput;
-       vs->vs_if.if_ubareset = vvreset;
-       vs->vs_ifuba.ifu_flags = UBA_NEEDBDP | UBA_NEED16;
+       vs->vs_if.if_reset = vvreset;
+       vs->vs_ifuba.ifu_flags = UBA_CANTWAIT | UBA_NEEDBDP | UBA_NEED16;
+#if defined(VAX750)
+       /* don't chew up 750 bdp's */
+       if (cpu == VAX_750 && ui->ui_unit > 0)
+               vs->vs_ifuba.ifu_flags &= ~UBA_NEEDBDP;
+#endif
        if_attach(&vs->vs_if);
 }
 
        if_attach(&vs->vs_if);
 }
 
@@ -144,7 +189,6 @@ vvreset(unit, uban)
        int unit, uban;
 {
        register struct uba_device *ui;
        int unit, uban;
 {
        register struct uba_device *ui;
-COUNT(VVRESET);
 
        if (unit >= NVV || (ui = vvinfo[unit]) == 0 || ui->ui_alive == 0 ||
            ui->ui_ubanum != uban)
 
        if (unit >= NVV || (ui = vvinfo[unit]) == 0 || ui->ui_alive == 0 ||
            ui->ui_ubanum != uban)
@@ -164,38 +208,94 @@ vvinit(unit)
        register struct uba_device *ui = vvinfo[unit];
        register struct vvreg *addr;
        struct sockaddr_in *sin;
        register struct uba_device *ui = vvinfo[unit];
        register struct vvreg *addr;
        struct sockaddr_in *sin;
-       struct mbuf *m;
-       struct vv_header *v;
-       int ubainfo, retrying, attempts, waitcount, s;
+       int ubainfo, s;
+       int vvtimeout();
 
 
+       if (vs->vs_if.if_net == 0)
+               return;
+       addr = (struct vvreg *)ui->ui_addr;
        if (if_ubainit(&vs->vs_ifuba, ui->ui_ubanum,
            sizeof (struct vv_header), (int)btoc(VVMTU)) == 0) { 
                printf("vv%d: can't initialize\n", unit);
        if (if_ubainit(&vs->vs_ifuba, ui->ui_ubanum,
            sizeof (struct vv_header), (int)btoc(VVMTU)) == 0) { 
                printf("vv%d: can't initialize\n", unit);
+               vs->vs_if.if_flags &= ~IFF_UP;
                return;
        }
                return;
        }
-       addr = (struct vvreg *)ui->ui_addr;
+       if (vv_ticking++ == 0)
+               timeout(vvtimeout, (caddr_t) 0, VV_FLYWHEEL);
+       /*
+        * Discover our host address and post it
+        */
+       vs->vs_if.if_host[0] = vvidentify(unit);
+       printf("vv%d: host %d\n", unit, vs->vs_if.if_host[0]);
+       sin = (struct sockaddr_in *)&vs->vs_if.if_addr;
+       sin->sin_family = AF_INET;
+       sin->sin_addr = if_makeaddr(vs->vs_if.if_net, vs->vs_if.if_host[0]);
+       sin = (struct sockaddr_in *)&vs->vs_if.if_broadaddr;
+       sin->sin_family = AF_INET;
+       sin->sin_addr = if_makeaddr(vs->vs_if.if_net, VV_BROADCAST);
+
+       /*
+        * Reset the interface, and join the ring
+        */
+       addr->vvocsr = VV_RST | VV_CPB;         /* clear packet buffer */
+       addr->vvicsr = VV_RST | VV_CONF;        /* close logical relay */
+       DELAY(500000);                          /* let contacts settle */
+       vs->vs_init = 0;
+       vs->vs_dropped = 0;
+       vs->vs_nottaken = 0;
+
+       /*
+        * Hang a receive and start any
+        * pending writes by faking a transmit complete.
+        */
+       s = splimp();
+       ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
+       addr->vviba = (u_short)ubainfo;
+       addr->vviea = (u_short)(ubainfo >> 16);
+       addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
+       addr->vvicsr = VV_IEN | VV_CONF | VV_DEN | VV_ENB;
+       vs->vs_iactive = ACTIVE;
+       vs->vs_oactive = 1;
+       vs->vs_if.if_flags |= IFF_UP | IFF_RUNNING;
+       vvxint(unit);
+       splx(s);
+       if_rtinit(&vs->vs_if, RTF_UP);
+}
+
+/*
+ * vvidentify() - return our host address
+ */
+vvidentify(unit)
+       int unit;
+{
+       register struct vv_softc *vs = &vv_softc[unit];
+       register struct uba_device *ui = vvinfo[unit];
+       register struct vvreg *addr;
+       struct mbuf *m;
+       struct vv_header *v;
+       int ubainfo, attempts, waitcount;
 
 
-#ifdef AUTOIDENTIFY
        /*
         * Build a multicast message to identify our address
         */
        /*
         * Build a multicast message to identify our address
         */
+       addr = (struct vvreg *)ui->ui_addr;
        attempts = 0;           /* total attempts, including bad msg type */
        attempts = 0;           /* total attempts, including bad msg type */
-top:
-       retrying = 0;           /* first time through */
-       m = m_get(M_DONTWAIT);
-       if (m == 0)
-               panic("vvinit: can't get mbuf");
+       m = m_get(M_DONTWAIT, MT_HEADER);
+       if (m == NULL)
+               return (0);
        m->m_next = 0;
        m->m_off = MMINOFF;
        m->m_len = sizeof(struct vv_header);
        m->m_next = 0;
        m->m_off = MMINOFF;
        m->m_len = sizeof(struct vv_header);
-
        v = mtod(m, struct vv_header *);
        v = mtod(m, struct vv_header *);
-       v->vh_dhost = 0;                /* multicast destination address */
+       v->vh_dhost = VV_BROADCAST;     /* multicast destination address */
        v->vh_shost = 0;                /* will be overwritten with ours */
        v->vh_version = RING_VERSION;
        v->vh_type = RING_WHOAMI;
        v->vh_info = 0;
        v->vh_shost = 0;                /* will be overwritten with ours */
        v->vh_version = RING_VERSION;
        v->vh_type = RING_WHOAMI;
        v->vh_info = 0;
-
+       /* map xmit message into uba */
+       vs->vs_olen =  if_wubaput(&vs->vs_ifuba, m);
+       if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
+               UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
        /*
         * Reset interface, establish Digital Loopback Mode, and
         * send the multicast (to myself) with Input Copy enabled.
        /*
         * Reset interface, establish Digital Loopback Mode, and
         * send the multicast (to myself) with Input Copy enabled.
@@ -207,39 +307,36 @@ retry:
        addr->vviea = (u_short) (ubainfo >> 16);
        addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
        addr->vvicsr = VV_STE | VV_DEN | VV_ENB | VV_LPB;
        addr->vviea = (u_short) (ubainfo >> 16);
        addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
        addr->vvicsr = VV_STE | VV_DEN | VV_ENB | VV_LPB;
-       /* map xmit message into uba if not already there */
-       if (!retrying)
-               vs->vs_olen =  if_wubaput(&vs->vs_ifuba, m);
-       if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
-               UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
+
+       /* let flag timers fire so ring will initialize */
+       DELAY(2000000);
+
        addr->vvocsr = VV_RST | VV_CPB; /* clear packet buffer */
        ubainfo = vs->vs_ifuba.ifu_w.ifrw_info;
        addr->vvoba = (u_short) ubainfo;
        addr->vvoea = (u_short) (ubainfo >> 16);
        addr->vvowc = -((vs->vs_olen + 1) >> 1);
        addr->vvocsr = VV_CPB | VV_DEN | VV_INR | VV_ENB;
        addr->vvocsr = VV_RST | VV_CPB; /* clear packet buffer */
        ubainfo = vs->vs_ifuba.ifu_w.ifrw_info;
        addr->vvoba = (u_short) ubainfo;
        addr->vvoea = (u_short) (ubainfo >> 16);
        addr->vvowc = -((vs->vs_olen + 1) >> 1);
        addr->vvocsr = VV_CPB | VV_DEN | VV_INR | VV_ENB;
-
        /*
         * Wait for receive side to finish.
         * Extract source address (which will our own),
         * and post to interface structure.
         */
        DELAY(1000);
        /*
         * Wait for receive side to finish.
         * Extract source address (which will our own),
         * and post to interface structure.
         */
        DELAY(1000);
-       for (waitcount = 0; ((addr->vvicsr) & VV_RDY) == 0; waitcount++) {
-               if (waitcount < 10)
+       for (waitcount = 0; (addr->vvicsr & VV_RDY) == 0; waitcount++) {
+               if (waitcount < 10) {
                        DELAY(1000);
                        DELAY(1000);
-               else {
-                       if (attempts++ < 10)s
-                               goto retry;
-                       else {
-                               printf("vv%d: can't initialize\n", unit);
-                               printf("vvinit loopwait: icsr = %b\n",
-                                       0xffff&(addr->vvicsr),VV_IBITS);
-                               return;
-                       }
+                       continue;
+               }
+               if (attempts++ >= 10) {
+                       printf("vv%d: can't initialize\n", unit);
+                       printf("vvinit loopwait: icsr = %b\n",
+                               0xffff&(addr->vvicsr), VV_IBITS);
+                       vs->vs_if.if_flags &= ~IFF_UP;
+                       return (0);
                }
                }
+               goto retry;
        }
        }
-
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
        if (vs->vs_ifuba.ifu_xtofree)
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
        if (vs->vs_ifuba.ifu_xtofree)
@@ -247,54 +344,163 @@ retry:
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_r.ifrw_bdp);
        m = if_rubaget(&vs->vs_ifuba, sizeof(struct vv_header), 0);
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_r.ifrw_bdp);
        m = if_rubaget(&vs->vs_ifuba, sizeof(struct vv_header), 0);
-       if (m)
+       if (m != NULL)
                m_freem(m);
        /*
                m_freem(m);
        /*
-        * check message type before we believe the source host address
+        * Check message type before we believe the source host address
         */
        v = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
         */
        v = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
-       if (v->vh_type == RING_WHOAMI)
-               vs->vs_if.if_host[0] = v->vh_shost;
-       else
-               goto top;
-#else
-       vs->vs_if.if_host[0] = 24;
-#endif
+       if (v->vh_type != RING_WHOAMI)
+               goto retry;
+       return(v->vh_shost);
+}
 
 
-       printf("vv%d: host %d\n", unit, vs->vs_if.if_host[0]);
-       sin = (struct sockaddr_in *)&vs->vs_if.if_addr;
-       sin->sin_family = AF_INET;
-       sin->sin_addr =
-           if_makeaddr(vs->vs_if.if_net, vs->vs_if.if_host[0]);
+/*
+ * vvtimeout() - called by timer flywheel to monitor input packet
+ * discard rate.  Interfaces getting too many errors are shut
+ * down for a while.  If the condition persists, the interface
+ * is marked down.
+ */
+/*ARGSUSED*/
+vvtimeout(junk)
+       int junk;
+{
+       register struct vv_softc *vs;
+       register int i;
+       register struct vvreg *addr;
+       int ubainfo;
 
 
-       /*
-        * Reset the interface, and join the ring
-        */
-       addr->vvocsr = VV_RST | VV_CPB;         /* clear packet buffer */
-       addr->vvicsr = VV_RST | VV_CONF;        /* close logical relay */
-       sleep((caddr_t)&lbolt, PZERO);          /* let contacts settle */
-       vs->vs_init = 0;
-       vs->vs_flush = 0;
-       vs->vs_nottaken = 0;
+       timeout(vvtimeout, (caddr_t) 0, VV_FLYWHEEL);
+       for (i = 0; i < NVV; i++) {
+               vs = &vv_softc[i];
+               addr = (struct vvreg *)vvinfo[i]->ui_addr;
+               if ((vs->vs_if.if_flags & IFF_UP) == 0)
+                       continue;
+               switch (vs->vs_major) {
+
+               /*
+                * MODE0: generally OK, just check error rate 
+                */
+               case MODE0:
+                       if (vs->vs_dropped < VV_ERRORTHRESHOLD) {
+                               vs->vs_dropped = 0;
+                               continue;
+                       }
+                       /* suspend reads for a while */
+                       vvtrprintf("vv%d going MODE1 in vvtimeout\n",i);
+                       vs->vs_major = MODE1;
+                       vs->vs_iactive = PAUSE; /* no new reads */
+                       vs->vs_retry = VV_MODE1ATTEMPTS;
+                       vs->vs_delayclock = VV_MODE1DELAY;
+                       vs->vs_minor = 0;
+                       continue;
+
+               /*
+                * MODE1: excessive error rate observed
+                * Scheme: try simply suspending reads for a
+                * short while a small number of times
+                */
+               case MODE1:
+                       if (vs->vs_delayclock > 0) {
+                               vs->vs_delayclock--;
+                               continue;
+                       }
+                       switch (vs->vs_minor) {
+
+                       case 0:                         /* reenable reads */
+                               vvtrprintf("vv%d M1m0\n",i);
+                               vs->vs_dropped = 0;
+                               vs->vs_iactive = ACTIVE;
+                               vs->vs_minor = 1;       /* next state */
+                               ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
+                               addr->vviba = (u_short) ubainfo;
+                               addr->vviea = (u_short) (ubainfo >> 16);
+                               addr->vviwc =
+                                 -(sizeof (struct vv_header) + VVMTU) >> 1;
+                               addr->vvicsr = VV_RST | VV_CONF;
+                               addr->vvicsr |= VV_IEN | VV_DEN | VV_ENB;
+                               continue;
+
+                       case 1:                         /* see if it worked */
+                               vvtrprintf("vv%d M1m1\n",i);
+                               if (vs->vs_dropped < VV_ERRORTHRESHOLD) {
+                                       vs->vs_dropped = 0;
+                                       vs->vs_major = MODE0;   /* yeah!! */
+                                       continue;
+                               }
+                               if (vs->vs_retry -- > 0) {
+                                       vs->vs_dropped = 0;
+                                       vs->vs_iactive = PAUSE;
+                                       vs->vs_delayclock = VV_MODE1DELAY;
+                                       vs->vs_minor = 0; /* recheck */
+                                       continue;
+                               }
+                               vs->vs_major = MODE2;
+                               vs->vs_minor = 0;
+                               vs->vs_dropped = 0;
+                               vs->vs_iactive = OPEN;
+                               vs->vs_delayrange = VV_MODE2DELAY;
+                               vs->vs_delayclock = VV_MODE2DELAY;
+                               /* fall thru ... */
+                       }
 
 
-       /*
-        * Hang a receive and start any
-        * pending writes by faking a transmit complete.
-        */
-       s = splimp();
-       ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
-       addr->vviba = (u_short) ubainfo;
-       addr->vviea = (u_short) (ubainfo >> 16);
-       addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
-       addr->vvicsr = VV_IEN | VV_CONF | VV_DEN | VV_ENB;
-       vs->vs_oactive = 1;
-       vvxint(unit);
-       splx(s);
-       if_rtinit(&vs->vs_if, RTF_UP);
+               /*
+                * MODE2: simply ignoring traffic didn't relieve condition
+                * Scheme: open host relay for intervals linearly
+                * increasing up to some maximum of a several minutes.
+                * This allows broken networks to return to operation
+                * without rebooting.
+                */
+               case MODE2:
+                       if (vs->vs_delayclock > 0) {
+                               vs->vs_delayclock--;
+                               continue;
+                       }
+                       switch (vs->vs_minor) {
+
+                       case 0:         /* close relay and reenable reads */
+                               vvtrprintf("vv%d M2m0\n",i);
+                               vs->vs_dropped = 0;
+                               vs->vs_iactive = ACTIVE;
+                               vs->vs_minor = 1;       /* next state */
+                               ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
+                               addr->vviba = (u_short) ubainfo;
+                               addr->vviea = (u_short) (ubainfo >> 16);
+                               addr->vviwc =
+                                 -(sizeof (struct vv_header) + VVMTU) >> 1;
+                               addr->vvicsr = VV_RST | VV_CONF;
+                               addr->vvicsr |= VV_IEN | VV_DEN | VV_ENB;
+                               continue;
+
+                       case 1:                         /* see if it worked */
+                               vvtrprintf("vv%d M2m1\n",i);
+                               if (vs->vs_dropped < VV_ERRORTHRESHOLD) {
+                                       vs->vs_dropped = 0;
+                                       vs->vs_major = MODE0;   /* yeah!! */
+                                       continue;
+                               }
+                               vvtrprintf("vv%d M2m1 ++ delay\n",i);
+                               vs->vs_dropped = 0;
+                               vs->vs_iactive = OPEN;
+                               vs->vs_minor = 0;
+                               if (vs->vs_delayrange < VV_MAXDELAY)
+                                       vs->vs_delayrange +=
+                                         (vs->vs_delayrange/2);
+                               vs->vs_delayclock = vs->vs_delayrange;
+                               continue;
+                       }
+
+               default:
+                       printf("vv%d: major state screwed\n", i);
+                       vs->vs_if.if_flags &= ~IFF_UP;
+               }
+       }
 }
 
 /*
  * Start or restart output on interface.
 }
 
 /*
  * Start or restart output on interface.
+ * If interface is active, this is a retransmit, so just
+ * restuff registers and go.
  * If interface is not already active, get another datagram
  * to send off of the interface queue, and map it to the interface
  * before starting the output.
  * If interface is not already active, get another datagram
  * to send off of the interface queue, and map it to the interface
  * before starting the output.
@@ -309,30 +515,31 @@ vvstart(dev)
        struct mbuf *m;
        int ubainfo;
        int dest;
        struct mbuf *m;
        int ubainfo;
        int dest;
-COUNT(VVSTART);
 
        if (vs->vs_oactive)
                goto restart;
 
        if (vs->vs_oactive)
                goto restart;
-
        /*
         * Not already active: dequeue another request
         * and map it to the UNIBUS.  If no more requests,
         * just return.
         */
        IF_DEQUEUE(&vs->vs_if.if_snd, m);
        /*
         * Not already active: dequeue another request
         * and map it to the UNIBUS.  If no more requests,
         * just return.
         */
        IF_DEQUEUE(&vs->vs_if.if_snd, m);
-       if (m == 0) {
+       if (m == NULL) {
                vs->vs_oactive = 0;
                return;
        }
        dest = mtod(m, struct vv_header *)->vh_dhost;
        vs->vs_olen = if_wubaput(&vs->vs_ifuba, m);
        vs->vs_lastx = dest;
                vs->vs_oactive = 0;
                return;
        }
        dest = mtod(m, struct vv_header *)->vh_dhost;
        vs->vs_olen = if_wubaput(&vs->vs_ifuba, m);
        vs->vs_lastx = dest;
-
 restart:
        /*
         * Have request mapped to UNIBUS for transmission.
         * Purge any stale data from this BDP, and start the otput.
         */
 restart:
        /*
         * Have request mapped to UNIBUS for transmission.
         * Purge any stale data from this BDP, and start the otput.
         */
+       if (vs->vs_olen > VVMTU + sizeof (struct vv_header)) {
+               printf("vv%d vs_olen: %d > VVMTU\n", unit, vs->vs_olen);
+               panic("vvdriver vs_olen botch");
+       }
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
        addr = (struct vvreg *)ui->ui_addr;
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_w.ifrw_bdp);
        addr = (struct vvreg *)ui->ui_addr;
@@ -355,7 +562,6 @@ vvxint(unit)
        register struct vv_softc *vs = &vv_softc[unit];
        register struct vvreg *addr;
        register int oc;
        register struct vv_softc *vs = &vv_softc[unit];
        register struct vvreg *addr;
        register int oc;
-COUNT(ENXINT);
 
        addr = (struct vvreg *)ui->ui_addr;
        oc = 0xffff & (addr->vvocsr);
 
        addr = (struct vvreg *)ui->ui_addr;
        oc = 0xffff & (addr->vvocsr);
@@ -365,12 +571,13 @@ COUNT(ENXINT);
                return;
        }
        if (oc &  (VV_OPT | VV_RFS)) {
                return;
        }
        if (oc &  (VV_OPT | VV_RFS)) {
-               if (++(vs->vs_tries) < VVRETRY) {
+               vs->vs_if.if_collisions++;
+               if (vs->vs_tries++ < VVRETRY) {
                        if (oc & VV_OPT)
                                vs->vs_init++;
                        if (oc & VV_RFS)
                                vs->vs_nottaken++;
                        if (oc & VV_OPT)
                                vs->vs_init++;
                        if (oc & VV_RFS)
                                vs->vs_nottaken++;
-                       addr->vvocsr = VV_IEN | VV_ENB | VV_INR;
+                       vvstart(unit);          /* restart this message */
                        return;
                }
                if (oc & VV_OPT)
                        return;
                }
                if (oc & VV_OPT)
@@ -389,7 +596,7 @@ COUNT(ENXINT);
                vs->vs_ifuba.ifu_xtofree = 0;
        }
        if (vs->vs_if.if_snd.ifq_head == 0) {
                vs->vs_ifuba.ifu_xtofree = 0;
        }
        if (vs->vs_if.if_snd.ifq_head == 0) {
-               vs->vs_lastx = 0;
+               vs->vs_lastx = 256;             /* an invalid address */
                return;
        }
        vvstart(unit);
                return;
        }
        vvstart(unit);
@@ -413,7 +620,7 @@ vvrint(unit)
        register struct ifqueue *inq;
        struct mbuf *m;
        int ubainfo, len, off;
        register struct ifqueue *inq;
        struct mbuf *m;
        int ubainfo, len, off;
-COUNT(VVRINT);
+       short resid;
 
        vs->vs_if.if_ipackets++;
        /*
 
        vs->vs_if.if_ipackets++;
        /*
@@ -422,55 +629,127 @@ COUNT(VVRINT);
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_r.ifrw_bdp);
        if (addr->vvicsr & VVRERR) {
        if (vs->vs_ifuba.ifu_flags & UBA_NEEDBDP)
                UBAPURGE(vs->vs_ifuba.ifu_uba, vs->vs_ifuba.ifu_r.ifrw_bdp);
        if (addr->vvicsr & VVRERR) {
-               vs->vs_if.if_ierrors++;
-               printf("vv%d: error vvicsr = %b\n", unit,
-                       0xffff&(addr->vvicsr), VV_IBITS);
-               goto setup;
+               if (vv_logreaderrors)
+                       printf("vv%d: error vvicsr = %b\n", unit,
+                               0xffff&(addr->vvicsr), VV_IBITS);
+               goto dropit;
        }
        }
-       off = 0;
-       len = 0;
+
+       /*
+        * Get packet length from word count residue
+        *
+        * Compute header offset if trailer protocol
+        *
+        * Pull packet off interface.  Off is nonzero if packet
+        * has trailing header; if_rubaget will then force this header
+        * information to be at the front.  The vh_info field
+        * carries the offset to the trailer data in trailer
+        * format packets.
+        */
        vv = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
        vv = (struct vv_header *)(vs->vs_ifuba.ifu_r.ifrw_addr);
+       vvtracehdr("vi", vv);
+       resid = addr->vviwc;
+       if (resid)
+               resid |= 0176000;               /* ugly!!!! */
+       len = (((sizeof (struct vv_header) + VVMRU) >> 1) + resid) << 1;
+       len -= sizeof(struct vv_header);
+       if (len > VVMRU || len <= 0)
+               goto dropit;
+#define        vvdataaddr(vv, off, type)       ((type)(((caddr_t)((vv)+1)+(off))))
+       if ((ifp->if_flags & IFF_NOTRAILERS) == 0)
+       if (vv->vh_type >= RING_IPTrailer &&
+            vv->vh_type < RING_IPTrailer+RING_IPNTrailer) {
+               off = (vv->vh_type - RING_IPTrailer) * 512;
+               if (off > VVMTU)
+                       goto dropit;
+               vv->vh_type = *vvdataaddr(vv, off, u_short *);
+               resid = *(vvdataaddr(vv, off+2, u_short *));
+               if (off + resid > len)
+                       goto dropit;
+               len = off + resid;
+       } else
+               off = 0;
+       if (len == 0)
+               goto dropit;
+       m = if_rubaget(&vs->vs_ifuba, len, off);
+       if (m == NULL)
+               goto dropit;
+       if (off) {
+               m->m_off += 2 * sizeof(u_short);
+               m->m_len -= 2 * sizeof(u_short);
+       }
+
        /*
        /*
-        * Demultiplex on packet type and deal with oddities of
-        * trailer protocol format
+        * Demultiplex on packet type 
         */
        switch (vv->vh_type) {
 
 #ifdef INET
        case RING_IP:
         */
        switch (vv->vh_type) {
 
 #ifdef INET
        case RING_IP:
-               len = htons((u_short)((struct ip *) vv)->ip_len);
                schednetisr(NETISR_IP);
                inq = &ipintrq;
                break;
 #endif
        default:
                printf("vv%d: unknown pkt type 0x%x\n", unit, vv->vh_type);
                schednetisr(NETISR_IP);
                inq = &ipintrq;
                break;
 #endif
        default:
                printf("vv%d: unknown pkt type 0x%x\n", unit, vv->vh_type);
+               m_freem(m);
                goto setup;
        }
                goto setup;
        }
-       if (len == 0)
-               goto setup;
+       if (IF_QFULL(inq)) {
+               IF_DROP(inq);
+               m_freem(m);
+       } else
+               IF_ENQUEUE(inq, m);
+setup:
        /*
        /*
-        * Pull packet off interface.  Off is nonzero if packet
-        * has trailing header; if_rubaget will then force this header
-        * information to be at the front, but we still have to drop
-        * the two-byte type which is at the front of any trailer data.
+        * Check the error rate and start recovery if needed
+        * this has to go here since the timer flywheel runs at
+        * a lower ipl and never gets a chance to change the mode
         */
         */
-       m = if_rubaget(&vs->vs_ifuba, len, off);
-       if (m == 0)
-               goto setup;
-       IF_ENQUEUE(inq, m);
+       if (vs->vs_major == MODE0 && vs->vs_dropped > VV_ERRORTHRESHOLD) {
+               vvtrprintf("vv%d going MODE1 in vvrint\n",unit);
+               vs->vs_major = MODE1;
+               vs->vs_iactive = PAUSE;         /* no new reads */
+               vs->vs_retry = VV_MODE1ATTEMPTS;
+               vs->vs_delayclock = VV_MODE1DELAY;
+               vs->vs_minor = 0;
+               vs->vs_dropped = 0;
+       }
+       switch (vs->vs_iactive) {
+
+       case ACTIVE:            /* Restart the read for next packet */
+               ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
+               addr->vviba = (u_short) ubainfo;
+               addr->vviea = (u_short) (ubainfo >> 16);
+               addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
+               addr->vvicsr = VV_RST | VV_CONF;
+               addr->vvicsr |= VV_IEN | VV_DEN | VV_ENB;
+               return;
 
 
-setup:
+       case PAUSE:             /* requested to not start any new reads */
+               vs->vs_dropped = 0;
+               return;
+
+       case OPEN:              /* request to open host relay */
+               vs->vs_dropped = 0;
+               addr->vvicsr = 0;
+               return;
+
+       default:
+               printf("vv%d: vs_iactive = %d\n", unit, vs->vs_iactive);
+               return;
+       }
        /*
        /*
-        * Reset for next packet.
+        * Drop packet on floor -- count them!!
         */
         */
-       ubainfo = vs->vs_ifuba.ifu_r.ifrw_info;
-       addr->vviba = (u_short) ubainfo;
-       addr->vviea = (u_short) (ubainfo >> 16);
-       addr->vviwc = -(sizeof (struct vv_header) + VVMTU) >> 1;
-       addr->vvicsr = VV_RST | VV_CONF;
-       addr->vvicsr |= VV_IEN | VV_DEN | VV_ENB;
-
+dropit:
+       vs->vs_if.if_ierrors++;
+       vs->vs_dropped++;
+       /*
+       printf("vv%d: error vvicsr = %b\n", unit,
+               0xffff&(addr->vvicsr), VV_IBITS);
+       */
+       goto setup;
 }
 
 /*
 }
 
 /*
@@ -486,16 +765,28 @@ vvoutput(ifp, m0, dst)
 {
        register struct mbuf *m = m0;
        register struct vv_header *vv;
 {
        register struct mbuf *m = m0;
        register struct vv_header *vv;
-       int type, dest, s;
+       register int off;
+       int type, dest, s, error;
 
        switch (dst->sa_family) {
 
 #ifdef INET
        case AF_INET: {
 
        switch (dst->sa_family) {
 
 #ifdef INET
        case AF_INET: {
-               register struct ip *ip = mtod(m0, struct ip *);
-               int off;
-
-               dest = ip->ip_dst.s_addr >> 24;
+               dest = ((struct sockaddr_in *)dst)->sin_addr.s_addr;
+               if ((dest = in_lnaof(*((struct in_addr *)&dest))) >= 0x100) {
+                       error = EPERM;
+                       goto bad;
+               }
+               off = ntohs((u_short)mtod(m, struct ip *)->ip_len) - m->m_len;
+               if (vv_dotrailer && off > 0 && (off & 0x1ff) == 0 &&
+                   m->m_off >= MMINOFF + 2 * sizeof (u_short)) {
+                       type = RING_IPTrailer + (off>>9);
+                       m->m_off -= 2 * sizeof (u_short);
+                       m->m_len += 2 * sizeof (u_short);
+                       *mtod(m, u_short *) = RING_IP;
+                       *(mtod(m, u_short *) + 1) = m->m_len;
+                       goto gottrailertype;
+               }
                type = RING_IP;
                off = 0;
                goto gottype;
                type = RING_IP;
                off = 0;
                goto gottype;
@@ -504,8 +795,8 @@ vvoutput(ifp, m0, dst)
        default:
                printf("vv%d: can't handle af%d\n", ifp->if_unit,
                        dst->sa_family);
        default:
                printf("vv%d: can't handle af%d\n", ifp->if_unit,
                        dst->sa_family);
-               m_freem(m0);
-               return (0);
+               error = EAFNOSUPPORT;
+               goto bad;
        }
 
 gottrailertype:
        }
 
 gottrailertype:
@@ -519,7 +810,6 @@ gottrailertype:
        m = m0->m_next;
        m0->m_next = 0;
        m0 = m;
        m = m0->m_next;
        m0->m_next = 0;
        m0 = m;
-
 gottype:
        /*
         * Add local net header.  If no space in first mbuf,
 gottype:
        /*
         * Add local net header.  If no space in first mbuf,
@@ -527,10 +817,10 @@ gottype:
         */
        if (m->m_off > MMAXOFF ||
            MMINOFF + sizeof (struct vv_header) > m->m_off) {
         */
        if (m->m_off > MMAXOFF ||
            MMINOFF + sizeof (struct vv_header) > m->m_off) {
-               m = m_get(M_DONTWAIT);
-               if (m == 0) {
-                       m_freem(m0);
-                       return (0);
+               m = m_get(M_DONTWAIT, MT_HEADER);
+               if (m == NULL) {
+                       error = ENOBUFS;
+                       goto bad;
                }
                m->m_next = m0;
                m->m_off = MMINOFF;
                }
                m->m_next = m0;
                m->m_off = MMINOFF;
@@ -544,21 +834,61 @@ gottype:
        vv->vh_dhost = dest;
        vv->vh_version = RING_VERSION;
        vv->vh_type = type;
        vv->vh_dhost = dest;
        vv->vh_version = RING_VERSION;
        vv->vh_type = type;
-       vv->vh_info = m->m_len;
+       vv->vh_info = off;
+       vvtracehdr("vo", vv);
 
        /*
         * Queue message on interface, and start output if interface
         * not yet active.
         */
        s = splimp();
 
        /*
         * Queue message on interface, and start output if interface
         * not yet active.
         */
        s = splimp();
+       if (IF_QFULL(&ifp->if_snd)) {
+               IF_DROP(&ifp->if_snd);
+               error = ENOBUFS;
+               goto qfull;
+       }
        IF_ENQUEUE(&ifp->if_snd, m);
        if (vv_softc[ifp->if_unit].vs_oactive == 0)
                vvstart(ifp->if_unit);
        splx(s);
        IF_ENQUEUE(&ifp->if_snd, m);
        if (vv_softc[ifp->if_unit].vs_oactive == 0)
                vvstart(ifp->if_unit);
        splx(s);
-       return (1);
+       return (0);
+qfull:
+       m0 = m;
+       splx(s);
+bad:
+       m_freem(m0);
+       return(error);
+}
+
+/*
+ * Process an ioctl request.
+ */
+vvioctl(ifp, cmd, data)
+       register struct ifnet *ifp;
+       int cmd;
+       caddr_t data;
+{
+       struct ifreq *ifr = (struct ifreq *)data;
+       int s = splimp(), error = 0;
+
+       switch (cmd) {
+
+       case SIOCSIFADDR:
+               /* too difficult to change addr while running */
+               if ((ifp->if_flags & IFF_RUNNING) == 0) {
+                       ifp->if_net = in_netof(ifr->ifr_addr.sin_addr);
+                       vvinit(ifp->if_unit);
+               } else
+                       error = EINVAL;
+               break;
+
+       default:
+               error = EINVAL;
+       }
+       splx(s);
+       return (error);
 }
 
 }
 
-#ifdef notdef
 /*
  * vvprt_hdr(s, v) print the local net header in "v"
  *     with title is "s"
 /*
  * vvprt_hdr(s, v) print the local net header in "v"
  *     with title is "s"
@@ -574,6 +904,7 @@ vvprt_hdr(s, v)
                0xffff & (int)(v->vh_info));
 }
 
                0xffff & (int)(v->vh_info));
 }
 
+#ifdef notdef
 /*
  * print "l" hex bytes starting at "s"
  */
 /*
  * print "l" hex bytes starting at "s"
  */