new format of error prints; no more FLAKEY UP resets

[unix-history] / usr / src / sys / vax / uba / uba.c

diff --git a/usr/src/sys/vax/uba/uba.c b/usr/src/sys/vax/uba/uba.c
index f5bcf09..5d5d830 100644 (file)
--- a/usr/src/sys/vax/uba/uba.c
+++ b/usr/src/sys/vax/uba/uba.c
@@ -1,4 +1,6 @@
-/*     uba.c   4.7     %G%     */
+/*     uba.c   4.19    %G%     */
+
+#define        DELAY(N)        { register int d; d = N; while (--d > 0); }

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -6,21 +8,94 @@
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"
 #include "../h/map.h"
 #include "../h/pte.h"
 #include "../h/buf.h"

+#include "../h/vm.h"

 #include "../h/uba.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/proc.h"
 #include "../h/uba.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/proc.h"

-#include "../h/vm.h"

 #include "../h/conf.h"
 #include "../h/mtpr.h"
 #include "../h/nexus.h"
 #include "../h/conf.h"
 #include "../h/mtpr.h"
 #include "../h/nexus.h"

+#include "../h/dk.h"
+
+#if VAX780
+char   ubasr_bits[] = UBASR_BITS;
+#endif
+
+/*
+ * Do transfer on device argument.  The controller
+ * and uba involved are implied by the device.
+ * We queue for resource wait in the uba code if necessary.
+ * We return 1 if the transfer was started, 0 if it was not.
+ * If you call this routine with the head of the queue for a
+ * UBA, it will automatically remove the device from the UBA
+ * queue before it returns.  If some other device is given
+ * as argument, it will be added to the request queue if the
+ * request cannot be started immediately.  This means that
+ * passing a device which is on the queue but not at the head
+ * of the request queue is likely to be a disaster.
+ */
+ubago(ui)
+       register struct uba_dinfo *ui;
+{
+       register struct uba_minfo *um = ui->ui_mi;
+       register struct uba_hd *uh;
+       register int s, unit;
+
+       uh = &uba_hd[um->um_ubanum];
+       s = spl6();
+       if (um->um_driver->ud_xclu && uh->uh_users > 0 || uh->uh_xclu)
+               goto rwait;
+       um->um_ubinfo = ubasetup(um->um_ubanum, um->um_tab.b_actf->b_actf,
+           UBA_NEEDBDP|UBA_CANTWAIT);
+       if (um->um_ubinfo == 0)
+               goto rwait;
+       uh->uh_users++;
+       if (um->um_driver->ud_xclu)
+               uh->uh_xclu = 1;
+       splx(s);
+       if (ui->ui_dk >= 0) {
+               unit = ui->ui_dk;
+               dk_busy |= 1<<unit;
+       }
+       if (uh->uh_actf == ui)
+               uh->uh_actf = ui->ui_forw;
+       (*um->um_driver->ud_dgo)(um);
+       if (ui->ui_dk >= 0) {
+               dk_xfer[unit]++;
+               dk_wds[unit] += um->um_tab.b_actf->b_bcount>>6;
+       }
+       return (1);
+rwait:
+       if (uh->uh_actf != ui) {
+               ui->ui_forw = NULL;
+               if (uh->uh_actf == NULL)
+                       uh->uh_actf = ui;
+               else
+                       uh->uh_actl->ui_forw = ui;
+               uh->uh_actl = ui;
+       }
+       splx(s);
+       return (0);
+}
+
+ubadone(um)
+       register struct uba_minfo *um;
+{
+       register struct uba_hd *uh = &uba_hd[um->um_ubanum];
+
+       if (um->um_driver->ud_xclu)
+               uh->uh_xclu = 0;
+       uh->uh_users--;
+       ubarelse(um->um_ubanum, &um->um_ubinfo);
+}

 
 /*
  * Allocate and setup UBA map registers, and bdp's
  * Flags says whether bdp is needed, whether the caller can't
  * wait (e.g. if the caller is at interrupt level).
  *
 
 /*
  * Allocate and setup UBA map registers, and bdp's
  * Flags says whether bdp is needed, whether the caller can't
  * wait (e.g. if the caller is at interrupt level).
  *

- * Return value (cruft):
+ * Return value:

  *     Bits 0-8        Byte offset
  *     Bits 9-17       Start map reg. no.
  *     Bits 18-27      No. mapping reg's
  *     Bits 0-8        Byte offset
  *     Bits 9-17       Start map reg. no.
  *     Bits 18-27      No. mapping reg's


@@ -41,26 +116,26 @@ ubasetup(uban, bp, flags)
        o = (int)bp->b_un.b_addr & PGOFSET;
        npf = btoc(bp->b_bcount + o) + 1;
        a = spl6();
        o = (int)bp->b_un.b_addr & PGOFSET;
        npf = btoc(bp->b_bcount + o) + 1;
        a = spl6();

-       while ((reg = malloc(uh->uh_map, npf)) == 0) {
+       while ((reg = rmalloc(uh->uh_map, npf)) == 0) {

                if (flags & UBA_CANTWAIT)
                        return (0);
                uh->uh_mrwant++;
                sleep((caddr_t)uh->uh_map, PSWP);
        }
                if (flags & UBA_CANTWAIT)
                        return (0);
                uh->uh_mrwant++;
                sleep((caddr_t)uh->uh_map, PSWP);
        }

-       reg--;

        bdp = 0;
        if (flags & UBA_NEEDBDP) {
                while ((bdp = ffs(uh->uh_bdpfree)) == 0) {
                        if (flags & UBA_CANTWAIT) {
        bdp = 0;
        if (flags & UBA_NEEDBDP) {
                while ((bdp = ffs(uh->uh_bdpfree)) == 0) {
                        if (flags & UBA_CANTWAIT) {

-                               mfree(uh->uh_map, npf, reg);
+                               rmfree(uh->uh_map, npf, reg);

                                return (0);
                        }
                        uh->uh_bdpwant++;
                        sleep((caddr_t)uh->uh_map, PSWP);
                }
                                return (0);
                        }
                        uh->uh_bdpwant++;
                        sleep((caddr_t)uh->uh_map, PSWP);
                }

-               uh->uh_bdpfree &= ~ (1<<bdp);
+               uh->uh_bdpfree &= ~(1 << (bdp-1));

        }
        splx(a);
        }
        splx(a);

+       reg--;

        ubinfo = (bdp << 28) | (npf << 18) | (reg << 9) | o;
        io = &uh->uh_uba->uba_map[reg];
        temp = (bdp << 21) | UBA_MRV;
        ubinfo = (bdp << 28) | (npf << 18) | (reg << 9) | o;
        io = &uh->uh_uba->uba_map[reg];
        temp = (bdp << 21) | UBA_MRV;


@@ -93,7 +168,7 @@ ubasetup(uban, bp, flags)
 }
 
 /*
 }
 
 /*

- * Non buffer unibus interface... set up a buffer and call ubasetup.
+ * Non buffer setup interface... set up a buffer and call ubasetup.

  */
 uballoc(uban, addr, bcnt, flags)
        caddr_t addr;
  */
 uballoc(uban, addr, bcnt, flags)
        caddr_t addr;


@@ -109,62 +184,132 @@ uballoc(uban, addr, bcnt, flags)
 }
  
 /*
 }
  
 /*

- * Old ubafree(info) is now ubarelse(&info) to avoid races.
+ * Release resources on uba uban, and then unblock resource waiters.
+ * The map register parameter is by value since we need to block
+ * against uba resets on 11/780's.

  */
 ubarelse(uban, amr)
        int *amr;
 {
        register struct uba_hd *uh = &uba_hd[uban];
  */
 ubarelse(uban, amr)
        int *amr;
 {
        register struct uba_hd *uh = &uba_hd[uban];

-       register int bdp, reg, npf, a;
+       register int bdp, reg, npf, s;

        int mr;
  
        int mr;
  

-       a = spl6();
+       /*
+        * Carefully see if we should release the space, since
+        * it may be released asynchronously at uba reset time.
+        */
+       s = spl6();

        mr = *amr;
        if (mr == 0) {
        mr = *amr;
        if (mr == 0) {

-               splx(a);
+               /*
+                * A ubareset() occurred before we got around
+                * to releasing the space... no need to bother.
+                */
+               splx(s);

                return;
        }
        *amr = 0;
                return;
        }
        *amr = 0;

+       splx(s);                /* let interrupts in, we're safe for a while */

        bdp = (mr >> 28) & 0x0f;
        if (bdp) {
        bdp = (mr >> 28) & 0x0f;
        if (bdp) {

-               uh->uh_uba->uba_dpr[bdp] |= UBA_BNE;
-               uh->uh_bdpfree |= 1 << bdp;
+               switch (cpu) {
+#if VAX780
+               case VAX_780:
+                       uh->uh_uba->uba_dpr[bdp] |= UBA_BNE;
+                       break;
+#endif
+#if VAX750
+               case VAX_750:
+                       uh->uh_uba->uba_dpr[bdp] |= UBA_PURGE|UBA_NXM|UBA_UCE;
+                       break;
+#endif
+               }
+               uh->uh_bdpfree |= 1 << (bdp-1);         /* atomic */

                if (uh->uh_bdpwant) {
                        uh->uh_bdpwant = 0;
                        wakeup((caddr_t)uh->uh_map);
                }
        }
                if (uh->uh_bdpwant) {
                        uh->uh_bdpwant = 0;
                        wakeup((caddr_t)uh->uh_map);
                }
        }

+       /*
+        * Put back the registers in the resource map.
+        * The map code must not be reentered, so we do this
+        * at high ipl.
+        */

        npf = (mr >> 18) & 0x3ff;
        reg = ((mr >> 9) & 0x1ff) + 1;
        npf = (mr >> 18) & 0x3ff;
        reg = ((mr >> 9) & 0x1ff) + 1;

-       mfree(uh->uh_map, npf, reg);
+       s = spl6();
+       rmfree(uh->uh_map, npf, reg);
+       splx(s);
+
+       /*
+        * Wakeup sleepers for map registers,
+        * and also, if there are processes blocked in dgo(),
+        * give them a chance at the UNIBUS.
+        */

        if (uh->uh_mrwant) {
                uh->uh_mrwant = 0;
                wakeup((caddr_t)uh->uh_map);
        }
        if (uh->uh_mrwant) {
                uh->uh_mrwant = 0;
                wakeup((caddr_t)uh->uh_map);
        }

-       splx(a);
+       while (uh->uh_actf && ubago(uh->uh_actf))
+               ;

 }
 
 }
 

-#define        DELAY(N)        { register int d; d = N; while (--d > 0); }
+ubapurge(um)
+       register struct uba_minfo *um;
+{
+       register struct uba_hd *uh = um->um_hd;
+       register int bdp = (um->um_ubinfo >> 28) & 0x0f;
+
+       switch (cpu) {
+#if VAX780
+       case VAX_780:
+               uh->uh_uba->uba_dpr[bdp] |= UBA_BNE;
+               break;
+#endif
+#if VAX750
+       case VAX_750:
+               uh->uh_uba->uba_dpr[bdp] |= UBA_PURGE|UBA_NXM|UBA_UCE;
+               break;
+#endif
+       }
+}

 
 

+/*
+ * Generate a reset on uba number uban.  Then
+ * call each device in the character device table,
+ * giving it a chance to clean up so as to be able to continue.
+ */

 ubareset(uban)
 ubareset(uban)

+       int uban;

 {
 {

-       struct uba_regs *up;

        register struct cdevsw *cdp;
        register struct cdevsw *cdp;

+       register struct uba_hd *uh = &uba_hd[uban];

        int s;
 
        s = spl6();
        int s;
 
        s = spl6();

+       uh->uh_users = 0;
+       uh->uh_zvcnt = 0;
+       uh->uh_xclu = 0;
+       uh->uh_hangcnt = 0;
+       uh->uh_actf = uh->uh_actl = 0;
+       uh->uh_bdpwant = 0;
+       uh->uh_mrwant = 0;
+       wakeup((caddr_t)&uh->uh_bdpwant);
+       wakeup((caddr_t)&uh->uh_mrwant);

        switch (cpu) {
        switch (cpu) {

-#if VAX==780
+#if VAX780

        case VAX_780:
        case VAX_780:

-               printf("UBA RESET %d:", uban);
-               ubainit(uba_hd[uban].uh_uba);
+               printf("uba%d: reset", uban);
+               ubainit(uh->uh_uba);

                break;
 #endif
                break;
 #endif

-#if VAX==750
+#if VAX750

        case VAX_750:
        case VAX_750:

-               printf("UNIBUS INIT:");
+               printf("uba0: reset");

                mtpr(IUR, 1);
                mtpr(IUR, 1);

-               DELAY(100000);
+               /* give devices time to recover from power fail */
+               DELAY(5000000);

                break;
 #endif
        }
                break;
 #endif
        }


@@ -174,18 +319,30 @@ ubareset(uban)
        splx(s);
 }
 
        splx(s);
 }
 

-/* pointer rather than number so we can be called with virt and phys addrs */
-ubainit(up)
-       register struct uba_regs *up;
+#if VAX780
+/*
+ * Init a uba.  This is called with a pointer
+ * rather than a virtual address since it is called
+ * by code which runs with memory mapping disabled.
+ * In these cases we really don't need the interrupts
+ * enabled, but since we run with ipl high, we don't care
+ * if they are, they will never happen anyways.
+ */
+ubainit(uba)
+       register struct uba_regs *uba;

 {
 
 {
 

-       up->uba_cr = UBA_ADINIT;
-       up->uba_cr = UBA_IFS|UBA_BRIE|UBA_USEFIE|UBA_SUEFIE;
-       while ((up->uba_cnfgr & UBA_UBIC) == 0)
+       uba->uba_cr = UBA_ADINIT;
+       uba->uba_cr = UBA_IFS|UBA_BRIE|UBA_USEFIE|UBA_SUEFIE;
+       while ((uba->uba_cnfgr & UBA_UBIC) == 0)

                ;
 }
 
                ;
 }
 

-#if VAX780
+/*
+ * Check to make sure the UNIBUS adaptor is not hung,
+ * with an interrupt in the register to be presented,
+ * but not presenting it for an extended period (5 seconds).
+ */

 unhang()
 {
        register int uban;
 unhang()
 {
        register int uban;


@@ -197,21 +354,27 @@ unhang()
                if (up->uba_sr == 0)
                        return;
                uh->uh_hangcnt++;
                if (up->uba_sr == 0)
                        return;
                uh->uh_hangcnt++;

-               if (uh->uh_hangcnt > 5*HZ) {
+               if (uh->uh_hangcnt > 5*hz) {

                        uh->uh_hangcnt = 0;
                        uh->uh_hangcnt = 0;

-                       printf("HANG ");
+                       printf("uba%d: hung\n", uban);

                        ubareset(uban);
                }
        }
 }
 
                        ubareset(uban);
                }
        }
 }
 

-/* timeout routine to decrement ``i forgot to interrupt counts */
-/* this prevents the counts from growing slowly, which isn't interesting */
+/*
+ * This is a timeout routine which decrements the ``i forgot to
+ * interrupt'' counts, on an 11/780.  This prevents slowly growing
+ * counts from causing a UBA reset since we are interested only
+ * in hang situations.
+ */

 ubawatch()
 {
        register struct uba_hd *uh;
        register int uban;
 
 ubawatch()
 {
        register struct uba_hd *uh;
        register int uban;
 

+       if (panicstr)
+               return;

        for (uban = 0; uban < numuba; uban++) {
                uh = &uba_hd[uban];
                if (uh->uh_hangcnt)
        for (uban = 0; uban < numuba; uban++) {
                uh = &uba_hd[uban];
                if (uh->uh_hangcnt)


@@ -219,7 +382,15 @@ ubawatch()
        }
 }
 
        }
 }
 

-/* called from locore.s; parameters here (i.e. uvec) are value-result! */
+/*
+ * This routine is called by the locore code to
+ * process a UBA error on an 11/780.  The arguments are passed
+ * on the stack, and value-result (through some trickery).
+ * In particular, the uvec argument is used for further
+ * uba processing so the result aspect of it is very important.
+ * It must not be declared register.
+ */
+/*ARGSUSED*/

 ubaerror(uban, uh, xx, uvec, uba)
        register int uban;
        register struct uba_hd *uh;
 ubaerror(uban, uh, xx, uvec, uba)
        register int uban;
        register struct uba_hd *uh;


@@ -231,23 +402,24 @@ ubaerror(uban, uh, xx, uvec, uba)
        if (uvec == 0) {
                uh->uh_zvcnt++;
                if (uh->uh_zvcnt > 250000) {
        if (uvec == 0) {
                uh->uh_zvcnt++;
                if (uh->uh_zvcnt > 250000) {

-                       printf("ZERO VECTOR ");
+                       printf("uba%d: too many zero vectors\n");

                        ubareset(uban);
                }
                uvec = 0;
                return;
        }
        if (uba->uba_cnfgr & NEX_CFGFLT) {
                        ubareset(uban);
                }
                uvec = 0;
                return;
        }
        if (uba->uba_cnfgr & NEX_CFGFLT) {

-               printf("UBA%d SBI FAULT sr %x cnfgr %x\n",
-                   uban, uba->uba_sr, uba->uba_cnfgr);
+               printf("uba%d: sbi fault sr=%b cnfgr=%b\n",
+                   uban, uba->uba_sr, ubasr_bits,
+                   uba->uba_cnfgr, nexflt_bits);

                ubareset(uban);
                uvec = 0;
                return;
        }
        sr = uba->uba_sr;
        s = spl7();
                ubareset(uban);
                uvec = 0;
                return;
        }
        sr = uba->uba_sr;
        s = spl7();

-       printf("UBA%d ERROR SR %x FMER %x FUBAR %o\n",
-           uba->uba_sr, uba->uba_fmer, uba->uba_fubar);
+       printf("uba%d: uba error sr=%x fmer=%x fubar=%o\n",
+           uban, uba->uba_sr, uba->uba_fmer, 4*uba->uba_fubar);

        splx(s);
        uba->uba_sr = sr;
        uvec &= UBA_DIV;
        splx(s);
        uba->uba_sr = sr;
        uvec &= UBA_DIV;