BSD 4_4 release

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

diff --git a/usr/src/sys/vax/if/if_uba.c b/usr/src/sys/vax/if/if_uba.c
index 9294c8c..f8f2cf6 100644 (file)
--- a/usr/src/sys/vax/if/if_uba.c
+++ b/usr/src/sys/vax/if/if_uba.c
@@ -1,20 +1,56 @@
-/*     if_uba.c        4.4     81/12/03        */
-
-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/mbuf.h"
-#include "../h/map.h"
-#include "../h/pte.h"
-#include "../h/buf.h"
-#include "../h/ubareg.h"
-#include "../h/ubavar.h"
-#include "../h/cmap.h"
-#include "../h/mtpr.h"
-#include "../h/vmmac.h"
-#include "../net/in.h"
-#include "../net/in_systm.h"
-#include "../net/if.h"
-#include "../net/if_uba.h"
+/*
+ * Copyright (c) 1982, 1986, 1988 Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     @(#)if_uba.c    7.16 (Berkeley) 12/16/90
+ */
+
+#include "sys/param.h"
+#include "sys/systm.h"
+#include "sys/malloc.h"
+#include "sys/mbuf.h"
+#include "sys/map.h"
+#include "sys/buf.h"
+#include "sys/cmap.h"
+#include "sys/vmmac.h"
+#include "sys/socket.h"
+#include "sys/syslog.h"
+
+#include "net/if.h"
+
+#include "../include/pte.h"
+#include "../include/mtpr.h"
+#include "if_uba.h"
+#include "../uba/ubareg.h"
+#include "../uba/ubavar.h"

 
 /*
  * Routines supporting UNIBUS network interfaces.
 
 /*
  * Routines supporting UNIBUS network interfaces.


@@ -27,153 +63,268 @@
  * Init UNIBUS for interface on uban whose headers of size hlen are to
  * end on a page boundary.  We allocate a UNIBUS map register for the page
  * with the header, and nmr more UNIBUS map registers for i/o on the adapter,
  * Init UNIBUS for interface on uban whose headers of size hlen are to
  * end on a page boundary.  We allocate a UNIBUS map register for the page
  * with the header, and nmr more UNIBUS map registers for i/o on the adapter,

- * doing this twice: once for reading and once for writing.  We also
+ * doing this once for each read and once for each write buffer.  We also

  * allocate page frames in the mbuffer pool for these pages.
  */
  * allocate page frames in the mbuffer pool for these pages.
  */

-if_ubainit(ifu, uban, hlen, nmr)
-       register struct ifuba *ifu;
-       int uban, hlen, nmr;
+if_ubaminit(ifu, uban, hlen, nmr, ifr, nr, ifw, nw)
+       register struct ifubinfo *ifu;
+       int uban, hlen, nmr, nr, nw;
+       register struct ifrw *ifr;
+       register struct ifxmt *ifw;

 {
 {

-       register caddr_t cp = (caddr_t)m_pgalloc(2 * (nmr + 1));
-       int i;
+       register caddr_t p;
+       caddr_t cp;
+       int i, nclbytes, off;

 
 

-COUNT(IF_UBAINIT);
-       if (cp == 0)
-               return (0);
-       ifu->ifu_hlen = hlen;
-       ifu->ifu_uban = uban;
-       ifu->ifu_uba = uba_hd[uban].uh_uba;
-       ifu->ifu_r.ifrw_addr = cp + NBPG - hlen;
-       ifu->ifu_w.ifrw_addr = ifu->ifu_r.ifrw_addr + (nmr + 1) * NBPG;
-       if (if_ubaalloc(ifu, &ifu->ifu_r, nmr) == 0)
-               goto bad;
-       if (if_ubaalloc(ifu, &ifu->ifu_w, nmr) == 0)
-               goto bad2;
-       for (i = 0; i < nmr; i++)
-               ifu->ifu_wmap[i] = ifu->ifu_w.ifrw_mr[i+1];
-       ifu->ifu_xswapd = 0;
+       if (hlen)
+               off = MCLBYTES - hlen;
+       else
+               off = 0;
+       nclbytes = roundup(nmr * NBPG, MCLBYTES);
+       if (hlen)
+               nclbytes += MCLBYTES;
+       if (ifr[0].ifrw_addr)
+               cp = ifr[0].ifrw_addr - off;
+       else {
+               cp = (caddr_t)malloc((u_long)((nr + nw) * nclbytes), M_DEVBUF,
+                   M_NOWAIT);
+               if (cp == 0)
+                       return (0);
+               p = cp;
+               for (i = 0; i < nr; i++) {
+                       ifr[i].ifrw_addr = p + off;
+                       p += nclbytes;
+               }
+               for (i = 0; i < nw; i++) {
+                       ifw[i].ifw_base = p;
+                       ifw[i].ifw_addr = p + off;
+                       p += nclbytes;
+               }
+               ifu->iff_hlen = hlen;
+               ifu->iff_uban = uban;
+               ifu->iff_uba = uba_hd[uban].uh_uba;
+               ifu->iff_ubamr = uba_hd[uban].uh_mr;
+       }
+       for (i = 0; i < nr; i++)
+               if (if_ubaalloc(ifu, &ifr[i], nmr) == 0) {
+                       nr = i;
+                       nw = 0;
+                       goto bad;
+               }
+       for (i = 0; i < nw; i++)
+               if (if_ubaalloc(ifu, &ifw[i].ifrw, nmr) == 0) {
+                       nw = i;
+                       goto bad;
+               }
+       while (--nw >= 0) {
+               for (i = 0; i < nmr; i++)
+                       ifw[nw].ifw_wmap[i] = ifw[nw].ifw_mr[i];
+               ifw[nw].ifw_xswapd = 0;
+               ifw[nw].ifw_flags = IFRW_W;
+               ifw[nw].ifw_nmr = nmr;
+       }

        return (1);
        return (1);

-bad2:
-       ubarelse(ifu->ifu_uban, &ifu->ifu_r.ifrw_info);

 bad:
 bad:

-       m_pgfree(cp, 2 * (nmr + 1));
+       while (--nw >= 0)
+               ubarelse(ifu->iff_uban, &ifw[nw].ifw_info);
+       while (--nr >= 0)
+               ubarelse(ifu->iff_uban, &ifr[nr].ifrw_info);
+       free(cp, M_DEVBUF);
+       ifr[0].ifrw_addr = 0;

        return (0);
 }
 
 /*
        return (0);
 }
 
 /*

- * Setup either a ifrw structure by allocating UNIBUS map registers,
- * a buffered data path, and initializing the fields of the ifrw structure
- * to minimize run-time overhead.
+ * Setup an ifrw structure by allocating UNIBUS map registers,
+ * possibly a buffered data path, and initializing the fields of
+ * the ifrw structure to minimize run-time overhead.

  */
 static
 if_ubaalloc(ifu, ifrw, nmr)
  */
 static
 if_ubaalloc(ifu, ifrw, nmr)

-       struct ifuba *ifu;
+       struct ifubinfo *ifu;

        register struct ifrw *ifrw;
        int nmr;
 {
        register int info;
 
        register struct ifrw *ifrw;
        int nmr;
 {
        register int info;
 

-COUNT(IF_UBAALLOC);

        info =
        info =

-           uballoc(ifu->ifu_uban, ifrw->ifrw_addr, nmr*NBPG + ifu->ifu_hlen,
-               UBA_NEED16|UBA_NEEDBDP);
+           uballoc(ifu->iff_uban, ifrw->ifrw_addr, nmr*NBPG + ifu->iff_hlen,
+               ifu->iff_flags);

        if (info == 0)
                return (0);
        ifrw->ifrw_info = info;
        ifrw->ifrw_bdp = UBAI_BDP(info);
        if (info == 0)
                return (0);
        ifrw->ifrw_info = info;
        ifrw->ifrw_bdp = UBAI_BDP(info);

-       ifrw->ifrw_proto = UBAMR_MRV | (UBAI_MR(info) << UBAMR_DPSHIFT);
-       ifrw->ifrw_mr = &ifu->ifu_uba->uba_map[UBAI_MR(info) + 1];
+       ifrw->ifrw_proto = UBAMR_MRV | (UBAI_BDP(info) << UBAMR_DPSHIFT);
+       ifrw->ifrw_mr = &ifu->iff_ubamr[UBAI_MR(info) + (ifu->iff_hlen? 1 : 0)];

        return (1);
 }
 
 /*
  * Pull read data off a interface.
        return (1);
 }
 
 /*
  * Pull read data off a interface.

- * Len is length of data, with local net header stripped.
+ * Totlen is length of data, with local net header stripped.

  * Off is non-zero if a trailer protocol was used, and
  * gives the offset of the trailer information.
  * Off is non-zero if a trailer protocol was used, and
  * gives the offset of the trailer information.

- * We copy the trailer information and then all the normal
+ * We copy the header from the trailer and then all the normal

  * data into mbufs.  When full cluster sized units are present
  * on the interface on cluster boundaries we can get them more
  * easily by remapping, and take advantage of this here.
  * data into mbufs.  When full cluster sized units are present
  * on the interface on cluster boundaries we can get them more
  * easily by remapping, and take advantage of this here.

+ * Save a pointer to the interface structure and the total length,
+ * so that protocols can determine where incoming packets arrived.
+ * Note: we may be called to receive from a transmit buffer by some
+ * devices.  In that case, we must force normal mapping of the buffer,
+ * so that the correct data will appear (only unibus maps are 
+ * changed when remapping the transmit buffers).

  */
 struct mbuf *
  */
 struct mbuf *

-if_rubaget(ifu, totlen, off0)
-       register struct ifuba *ifu;
-       int totlen, off0;
+if_ubaget(ifu, ifr, totlen, off, ifp)
+       struct ifubinfo *ifu;
+       register struct ifrw *ifr;
+       register int totlen;
+       int off;
+       struct ifnet *ifp;

 {
 {

-       struct mbuf *top, **mp, *m;
-       int off = off0, len;
-       register caddr_t cp;
-
-COUNT(IF_RUBAGET);
+       struct mbuf *top, **mp;
+       register struct mbuf *m;
+       register caddr_t cp = ifr->ifrw_addr + ifu->iff_hlen, pp;
+       register int len;
+       caddr_t epkt = cp + totlen;

 
        top = 0;
        mp = &top;
 
        top = 0;
        mp = &top;

+       /*
+        * Skip the trailer header (type and trailer length).
+        */
+       if (off) {
+               off += 2 * sizeof(u_short);
+               totlen -= 2 * sizeof(u_short);
+               cp += off;
+       }
+       MGETHDR(m, M_DONTWAIT, MT_DATA);
+       if (m == 0)
+               return ((struct mbuf *)NULL);
+       m->m_pkthdr.rcvif = ifp;
+       m->m_pkthdr.len = totlen;
+       m->m_len = MHLEN;
+
+       if (ifr->ifrw_flags & IFRW_W)
+               rcv_xmtbuf((struct ifxmt *)ifr);
+

        while (totlen > 0) {
        while (totlen > 0) {

-               MGET(m, 0);
-               if (m == 0)
-                       goto bad;
-               if (off) {
-                       len = totlen - off;
-                       cp = ifu->ifu_r.ifrw_addr + ifu->ifu_hlen + off;
-               } else
-                       len = totlen;
-               if (len >= CLSIZE) {
-                       struct mbuf *p;
+               if (top) {
+                       MGET(m, M_DONTWAIT, MT_DATA);
+                       if (m == 0) {
+                               m_freem(top);
+                               top = 0;
+                               goto out;
+                       }
+                       m->m_len = MLEN;
+               }
+               len = min(totlen, epkt - cp);
+               if (len >= MINCLSIZE) {

                        struct pte *cpte, *ppte;
                        int x, *ip, i;
 
                        struct pte *cpte, *ppte;
                        int x, *ip, i;
 

-                       MCLGET(p, 1);
-                       if (p == 0)
+                       MCLGET(m, M_DONTWAIT);
+                       if ((m->m_flags & M_EXT) == 0)

                                goto nopage;
                                goto nopage;

-                       m->m_len = CLSIZE;
-                       m->m_off = (int)p - (int)m;
+                       len = min(len, MCLBYTES);
+                       m->m_len = len;

                        if (!claligned(cp))
                                goto copy;
 
                        /*
                        if (!claligned(cp))
                                goto copy;
 
                        /*

-                        * Switch pages mapped to UNIBUS with new page p,
+                        * Switch pages mapped to UNIBUS with new page pp,

                         * as quick form of copy.  Remap UNIBUS and invalidate.
                         */
                         * as quick form of copy.  Remap UNIBUS and invalidate.
                         */

-                       cpte = &Mbmap[mtocl(cp)*CLSIZE];
-                       ppte = &Mbmap[mtocl(p)*CLSIZE];
-                       x = btop(cp - ifu->ifu_r.ifrw_addr);
-                       ip = (int *)&ifu->ifu_r.ifrw_mr[x+1];
-                       for (i = 0; i < CLSIZE; i++) {
+                       pp = mtod(m, char *);
+                       cpte = kvtopte(cp);
+                       ppte = kvtopte(pp);
+                       x = btop(cp - ifr->ifrw_addr);
+                       ip = (int *)&ifr->ifrw_mr[x];
+                       for (i = 0; i < MCLBYTES/NBPG; i++) {

                                struct pte t;
                                t = *ppte; *ppte++ = *cpte; *cpte = t;
                                struct pte t;
                                t = *ppte; *ppte++ = *cpte; *cpte = t;

-                               *ip++ =
-                                   cpte++->pg_pfnum|ifu->ifu_r.ifrw_proto;
+                               *ip++ = cpte++->pg_pfnum|ifr->ifrw_proto;

                                mtpr(TBIS, cp);
                                cp += NBPG;
                                mtpr(TBIS, cp);
                                cp += NBPG;

-                               mtpr(TBIS, (caddr_t)p);
-                               p += NBPG / sizeof (*p);
+                               mtpr(TBIS, (caddr_t)pp);
+                               pp += NBPG;

                        }
                        goto nocopy;
                }
 nopage:
                        }
                        goto nocopy;
                }
 nopage:

-               m->m_len = MIN(MLEN, len);
-               m->m_off = MMINOFF;
+               if (len < m->m_len) {
+                       /*
+                        * Place initial small packet/header at end of mbuf.
+                        */
+                       if (top == 0 && len + max_linkhdr <= m->m_len)
+                               m->m_data += max_linkhdr;
+                       m->m_len = len;
+               } else
+                       len = m->m_len;

 copy:
 copy:

-               bcopy(cp, mtod(m, caddr_t), (unsigned)m->m_len);
-               cp += m->m_len;
+               bcopy(cp, mtod(m, caddr_t), (unsigned)len);
+               cp += len;

 nocopy:
                *mp = m;
                mp = &m->m_next;
 nocopy:
                *mp = m;
                mp = &m->m_next;

-               if (off) {
-                       /* sort of an ALGOL-W style for statement... */
-                       off += m->m_len;
-                       if (off == totlen) {
-                               cp = ifu->ifu_r.ifrw_addr + ifu->ifu_hlen;
-                               off = 0;
-                               totlen -= off0;
-                       }
-               }
+               totlen -= len;
+               if (cp == epkt)
+                       cp = ifr->ifrw_addr + ifu->iff_hlen;

        }
        }

+out:
+       if (ifr->ifrw_flags & IFRW_W)
+               restor_xmtbuf((struct ifxmt *)ifr);

        return (top);
        return (top);

-bad:
-       m_freem(top);
-       return (0);
+}
+
+/*
+ * Change the mapping on a transmit buffer so that if_ubaget may
+ * receive from that buffer.  Copy data from any pages mapped to Unibus
+ * into the pages mapped to normal kernel virtual memory, so that
+ * they can be accessed and swapped as usual.  We take advantage
+ * of the fact that clusters are placed on the xtofree list
+ * in inverse order, finding the last one.
+ */
+static
+rcv_xmtbuf(ifw)
+       register struct ifxmt *ifw;
+{
+       register struct mbuf *m;
+       struct mbuf **mprev;
+       register i;
+       char *cp;
+
+       while (i = ffs((long)ifw->ifw_xswapd)) {
+               cp = ifw->ifw_base + i * MCLBYTES;
+               i--;
+               ifw->ifw_xswapd &= ~(1<<i);
+               mprev = &ifw->ifw_xtofree;
+               for (m = ifw->ifw_xtofree; m && m->m_next; m = m->m_next)
+                       mprev = &m->m_next;
+               if (m == NULL)
+                       break;
+               bcopy(mtod(m, caddr_t), cp, MCLBYTES);
+               (void) m_free(m);
+               *mprev = NULL;
+       }
+       ifw->ifw_xswapd = 0;
+       for (i = 0; i < ifw->ifw_nmr; i++)
+               ifw->ifw_mr[i] = ifw->ifw_wmap[i];
+}
+
+/*
+ * Put a transmit buffer back together after doing an if_ubaget on it,
+ * which may have swapped pages.
+ */
+static
+restor_xmtbuf(ifw)
+       register struct ifxmt *ifw;
+{
+       register i;
+
+       for (i = 0; i < ifw->ifw_nmr; i++)
+               ifw->ifw_wmap[i] = ifw->ifw_mr[i];

 }
 
 /*
 }
 
 /*


@@ -183,33 +334,34 @@ bad:
  * header which is copied to be in the mapped, aligned
  * i/o space.
  */
  * header which is copied to be in the mapped, aligned
  * i/o space.
  */

-if_wubaput(ifu, m)
-       register struct ifuba *ifu;
+if_ubaput(ifu, ifw, m)
+       struct ifubinfo *ifu;
+       register struct ifxmt *ifw;

        register struct mbuf *m;
 {
        register struct mbuf *mp;
        register caddr_t cp, dp;
        register int i;
        int xswapd = 0;
        register struct mbuf *m;
 {
        register struct mbuf *mp;
        register caddr_t cp, dp;
        register int i;
        int xswapd = 0;

-       int x, cc;
+       int x, cc, t;

 
 

-COUNT(IF_WUBAPUT);
-       ifu->ifu_xswapd = 0;
-       cp = ifu->ifu_w.ifrw_addr;
+       cp = ifw->ifw_addr;

        while (m) {
                dp = mtod(m, char *);
        while (m) {
                dp = mtod(m, char *);

-               if (claligned(cp) && claligned(dp)) {
-                       struct pte *pte; int *ip;
-                       pte = &Mbmap[mtocl(dp)*CLSIZE];
-                       x = btop(cp - ifu->ifu_w.ifrw_addr);
-                       ip = (int *)&ifu->ifu_w.ifrw_mr[x + 1];
-                       for (i = 0; i < CLSIZE; i++)
-                               *ip++ =
-                                   ifu->ifu_w.ifrw_proto | pte++->pg_pfnum;
-                       ifu->ifu_xswapd |= 1 << (x>>(CLSHIFT-PGSHIFT));
+               if (claligned(cp) && claligned(dp) &&
+                   (m->m_len == MCLBYTES || m->m_next == (struct mbuf *)0)) {
+                       struct pte *pte;
+                       int *ip;
+
+                       pte = kvtopte(dp);
+                       x = btop(cp - ifw->ifw_addr);
+                       ip = (int *)&ifw->ifw_mr[x];
+                       for (i = 0; i < MCLBYTES/NBPG; i++)
+                               *ip++ = ifw->ifw_proto | pte++->pg_pfnum;
+                       xswapd |= 1 << (x>>(MCLSHIFT-PGSHIFT));

                        mp = m->m_next;
                        mp = m->m_next;

-                       m->m_next = ifu->ifu_xtofree;
-                       ifu->ifu_xtofree = m;
+                       m->m_next = ifw->ifw_xtofree;
+                       ifw->ifw_xtofree = m;

                        cp += m->m_len;
                } else {
                        bcopy(mtod(m, caddr_t), cp, (unsigned)m->m_len);
                        cp += m->m_len;
                } else {
                        bcopy(mtod(m, caddr_t), cp, (unsigned)m->m_len);


@@ -220,27 +372,26 @@ COUNT(IF_WUBAPUT);
        }
 
        /*
        }
 
        /*

-        * Xswapd is the set of clusters we just mapped out.  Ifu->ifu_xswapd
+        * Xswapd is the set of clusters we just mapped out.  Ifu->iff_xswapd

         * is the set of clusters mapped out from before.  We compute
         * the number of clusters involved in this operation in x.
         * Clusters mapped out before and involved in this operation
         * should be unmapped so original pages will be accessed by the device.
         */
         * is the set of clusters mapped out from before.  We compute
         * the number of clusters involved in this operation in x.
         * Clusters mapped out before and involved in this operation
         * should be unmapped so original pages will be accessed by the device.
         */

-       cc = cp - ifu->ifu_w.ifrw_addr;
-       x = ((cc - ifu->ifu_hlen) + CLBYTES - 1) >> CLSHIFT;
-       xswapd &= ~ifu->ifu_xswapd;
-       if (xswapd)
-               while (i = ffs(xswapd)) {
-                       i--;
-                       if (i >= x)
-                               break;
-                       xswapd &= ~(1<<i);
-                       i *= CLSIZE;
-                       for (x = 0; x < CLSIZE; x++) {
-                               ifu->ifu_w.ifrw_mr[i] = ifu->ifu_wmap[i];
-                               i++;
-                       }
+       cc = cp - ifw->ifw_addr;
+       x = ((cc - ifu->iff_hlen) + MCLBYTES - 1) >> MCLSHIFT;
+       ifw->ifw_xswapd &= ~xswapd;
+       while (i = ffs((long)ifw->ifw_xswapd)) {
+               i--;
+               if (i >= x)
+                       break;
+               ifw->ifw_xswapd &= ~(1<<i);
+               i *= MCLBYTES/NBPG;
+               for (t = 0; t < MCLBYTES/NBPG; t++) {
+                       ifw->ifw_mr[i] = ifw->ifw_wmap[i];
+                       i++;

                }
                }

-       ifu->ifu_xswapd |= xswapd;
+       }
+       ifw->ifw_xswapd |= xswapd;

        return (cc);
 }
        return (cc);
 }