add definition for ability to produce a backtrace

[unix-history] / usr / src / sys / kern / uipc_socket2.c

diff --git a/usr/src/sys/kern/uipc_socket2.c b/usr/src/sys/kern/uipc_socket2.c
index b30cba4..b81f6ee 100644 (file)
--- a/usr/src/sys/kern/uipc_socket2.c
+++ b/usr/src/sys/kern/uipc_socket2.c
@@ -1,23 +1,22 @@
 /*
 /*

- * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
- * All rights reserved.
+ * Copyright (c) 1982, 1986, 1988, 1990, 1993
+ *     The Regents of the University of California.  All rights reserved.

  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)uipc_socket2.c      7.17 (Berkeley) %G%
+ *     @(#)uipc_socket2.c      8.2 (Berkeley) %G%

  */
 
  */
 

-#include "param.h"
-#include "systm.h"
-#include "user.h"
-#include "proc.h"
-#include "file.h"
-#include "buf.h"
-#include "malloc.h"
-#include "mbuf.h"
-#include "protosw.h"
-#include "socket.h"
-#include "socketvar.h"
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/file.h>
+#include <sys/buf.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>

 
 /*
  * Primitive routines for operating on sockets and socket buffers
 
 /*
  * Primitive routines for operating on sockets and socket buffers


@@ -60,6 +59,7 @@ u_long        sb_max = SB_MAX;                /* patchable */
  * cause software-interrupt process scheduling.
  */
 
  * cause software-interrupt process scheduling.
  */
 

+void

 soisconnecting(so)
        register struct socket *so;
 {
 soisconnecting(so)
        register struct socket *so;
 {


@@ -68,6 +68,7 @@ soisconnecting(so)
        so->so_state |= SS_ISCONNECTING;
 }
 
        so->so_state |= SS_ISCONNECTING;
 }
 

+void

 soisconnected(so)
        register struct socket *so;
 {
 soisconnected(so)
        register struct socket *so;
 {


@@ -86,6 +87,7 @@ soisconnected(so)
        }
 }
 
        }
 }
 

+void

 soisdisconnecting(so)
        register struct socket *so;
 {
 soisdisconnecting(so)
        register struct socket *so;
 {


@@ -97,6 +99,7 @@ soisdisconnecting(so)
        sorwakeup(so);
 }
 
        sorwakeup(so);
 }
 

+void

 soisdisconnected(so)
        register struct socket *so;
 {
 soisdisconnected(so)
        register struct socket *so;
 {


@@ -156,6 +159,7 @@ sonewconn1(head, connstatus)
        return (so);
 }
 
        return (so);
 }
 

+void

 soqinsque(head, so, q)
        register struct socket *head, *so;
        int q;
 soqinsque(head, so, q)
        register struct socket *head, *so;
        int q;


@@ -177,6 +181,7 @@ soqinsque(head, so, q)
        *prev = so;
 }
 
        *prev = so;
 }
 

+int

 soqremque(so, q)
        register struct socket *so;
        int q;
 soqremque(so, q)
        register struct socket *so;
        int q;


@@ -215,6 +220,7 @@ soqremque(so, q)
  * Data queued for reading in the socket may yet be read.
  */
 
  * Data queued for reading in the socket may yet be read.
  */
 

+void

 socantsendmore(so)
        struct socket *so;
 {
 socantsendmore(so)
        struct socket *so;
 {


@@ -223,6 +229,7 @@ socantsendmore(so)
        sowwakeup(so);
 }
 
        sowwakeup(so);
 }
 

+void

 socantrcvmore(so)
        struct socket *so;
 {
 socantrcvmore(so)
        struct socket *so;
 {


@@ -231,29 +238,10 @@ socantrcvmore(so)
        sorwakeup(so);
 }
 
        sorwakeup(so);
 }
 

-/*
- * Socket select/wakeup routines.
- */
-
-/*
- * Queue a process for a select on a socket buffer.
- */
-sbselqueue(sb)
-       struct sockbuf *sb;
-{
-       struct proc *p;
-
-       if ((p = sb->sb_sel) && p->p_wchan == (caddr_t)&selwait)
-               sb->sb_flags |= SB_COLL;
-       else {
-               sb->sb_sel = u.u_procp;
-               sb->sb_flags |= SB_SEL;
-       }
-}
-

 /*
  * Wait for data to arrive at/drain from a socket buffer.
  */
 /*
  * Wait for data to arrive at/drain from a socket buffer.
  */

+int

 sbwait(sb)
        struct sockbuf *sb;
 {
 sbwait(sb)
        struct sockbuf *sb;
 {


@@ -268,6 +256,7 @@ sbwait(sb)
  * Lock a sockbuf already known to be locked;
  * return any error returned from sleep (EINTR).
  */
  * Lock a sockbuf already known to be locked;
  * return any error returned from sleep (EINTR).
  */

+int

 sb_lock(sb)
        register struct sockbuf *sb;
 {
 sb_lock(sb)
        register struct sockbuf *sb;
 {


@@ -289,17 +278,15 @@ sb_lock(sb)
  * Do asynchronous notification via SIGIO
  * if the socket has the SS_ASYNC flag set.
  */
  * Do asynchronous notification via SIGIO
  * if the socket has the SS_ASYNC flag set.
  */

+void

 sowakeup(so, sb)
        register struct socket *so;
        register struct sockbuf *sb;
 {
        struct proc *p;
 
 sowakeup(so, sb)
        register struct socket *so;
        register struct sockbuf *sb;
 {
        struct proc *p;
 

-       if (sb->sb_sel) {
-               selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL);
-               sb->sb_sel = 0;
-               sb->sb_flags &= ~(SB_SEL|SB_COLL);
-       }
+       selwakeup(&sb->sb_sel);
+       sb->sb_flags &= ~SB_SEL;

        if (sb->sb_flags & SB_WAIT) {
                sb->sb_flags &= ~SB_WAIT;
                wakeup((caddr_t)&sb->sb_cc);
        if (sb->sb_flags & SB_WAIT) {
                sb->sb_flags &= ~SB_WAIT;
                wakeup((caddr_t)&sb->sb_cc);


@@ -344,6 +331,7 @@ sowakeup(so, sb)
  * should be released by calling sbrelease() when the socket is destroyed.
  */
 
  * should be released by calling sbrelease() when the socket is destroyed.
  */
 

+int

 soreserve(so, sndcc, rcvcc)
        register struct socket *so;
        u_long sndcc, rcvcc;
 soreserve(so, sndcc, rcvcc)
        register struct socket *so;
        u_long sndcc, rcvcc;


@@ -371,6 +359,7 @@ bad:
  * Attempt to scale mbmax so that mbcnt doesn't become limiting
  * if buffering efficiency is near the normal case.
  */
  * Attempt to scale mbmax so that mbcnt doesn't become limiting
  * if buffering efficiency is near the normal case.
  */

+int

 sbreserve(sb, cc)
        struct sockbuf *sb;
        u_long cc;
 sbreserve(sb, cc)
        struct sockbuf *sb;
        u_long cc;


@@ -388,6 +377,7 @@ sbreserve(sb, cc)
 /*
  * Free mbufs held by a socket, and reserved mbuf space.
  */
 /*
  * Free mbufs held by a socket, and reserved mbuf space.
  */

+void

 sbrelease(sb)
        struct sockbuf *sb;
 {
 sbrelease(sb)
        struct sockbuf *sb;
 {


@@ -427,28 +417,24 @@ sbrelease(sb)
  * the mbuf chain is recorded in sb.  Empty mbufs are
  * discarded and mbufs are compacted where possible.
  */
  * the mbuf chain is recorded in sb.  Empty mbufs are
  * discarded and mbufs are compacted where possible.
  */

+void

 sbappend(sb, m)
        struct sockbuf *sb;
        struct mbuf *m;
 {
 sbappend(sb, m)
        struct sockbuf *sb;
        struct mbuf *m;
 {

-       register struct mbuf *n;
+       register struct mbuf *n, *n0;

 
        if (m == 0)
                return;
        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;
 
        if (m == 0)
                return;
        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;

-               do {
-                       if (n->m_flags & M_EOR) {
-                               sbappendrecord(sb, m); /* XXXXXX!!!! */
-                               return;
-                       }
-               } while (n->m_next && (n = n->m_next));

        }
        sbcompress(sb, m, n);
 }
 
 #ifdef SOCKBUF_DEBUG
        }
        sbcompress(sb, m, n);
 }
 
 #ifdef SOCKBUF_DEBUG

+void

 sbcheck(sb)
        register struct sockbuf *sb;
 {
 sbcheck(sb)
        register struct sockbuf *sb;
 {


@@ -475,6 +461,7 @@ sbcheck(sb)
  * As above, except the mbuf chain
  * begins a new record.
  */
  * As above, except the mbuf chain
  * begins a new record.
  */

+void

 sbappendrecord(sb, m0)
        register struct sockbuf *sb;
        register struct mbuf *m0;
 sbappendrecord(sb, m0)
        register struct sockbuf *sb;
        register struct mbuf *m0;


@@ -497,10 +484,6 @@ sbappendrecord(sb, m0)
                sb->sb_mb = m0;
        m = m0->m_next;
        m0->m_next = 0;
                sb->sb_mb = m0;
        m = m0->m_next;
        m0->m_next = 0;

-       if (m && (m0->m_flags & M_EOR)) {
-               m0->m_flags &= ~M_EOR;
-               m->m_flags |= M_EOR;
-       }

        sbcompress(sb, m, m0);
 }
 
        sbcompress(sb, m, m0);
 }
 


@@ -509,6 +492,7 @@ sbappendrecord(sb, m0)
  * is inserted at the beginning of the sockbuf,
  * but after any other OOB data.
  */
  * is inserted at the beginning of the sockbuf,
  * but after any other OOB data.
  */

+void

 sbinsertoob(sb, m0)
        register struct sockbuf *sb;
        register struct mbuf *m0;
 sbinsertoob(sb, m0)
        register struct sockbuf *sb;
        register struct mbuf *m0;


@@ -535,16 +519,10 @@ sbinsertoob(sb, m0)
         * Put the first mbuf on the queue.
         * Note this permits zero length records.
         */
         * Put the first mbuf on the queue.
         * Note this permits zero length records.
         */

-       sballoc(sb, m0);

        m0->m_nextpkt = *mp;
        *mp = m0;
        m0->m_nextpkt = *mp;
        *mp = m0;

-       m = m0->m_next;
-       m0->m_next = 0;
-       if (m && (m0->m_flags & M_EOR)) {
-               m0->m_flags &= ~M_EOR;
-               m->m_flags |= M_EOR;
-       }
-       sbcompress(sb, m, m0);
+       for (m = m0; m; m = m->m_next)
+               sballoc(sb, m);

 }
 
 /*
 }
 
 /*


@@ -553,13 +531,14 @@ sbinsertoob(sb, m0)
  * m0 must include a packet header with total length.
  * Returns 0 if no space in sockbuf or insufficient mbufs.
  */
  * m0 must include a packet header with total length.
  * Returns 0 if no space in sockbuf or insufficient mbufs.
  */

+int

 sbappendaddr(sb, asa, m0, control)
        register struct sockbuf *sb;
        struct sockaddr *asa;
        struct mbuf *m0, *control;
 {
        register struct mbuf *m, *n;
 sbappendaddr(sb, asa, m0, control)
        register struct sockbuf *sb;
        struct sockaddr *asa;
        struct mbuf *m0, *control;
 {
        register struct mbuf *m, *n;

-       int space = asa->sa_len;
+       int space = asa->sa_len, eor = 0;

 
 if (m0 && (m0->m_flags & M_PKTHDR) == 0)
 panic("sbappendaddr");
 
 if (m0 && (m0->m_flags & M_PKTHDR) == 0)
 panic("sbappendaddr");


@@ -584,8 +563,11 @@ panic("sbappendaddr");
        else
                control = m0;
        m->m_next = control;
        else
                control = m0;
        m->m_next = control;

-       for (n = m; n; n = n->m_next)
+       for (n = m; n; n = n->m_next) {
+               eor |= n->m_flags & M_EOR;

                sballoc(sb, n);
                sballoc(sb, n);

+       }
+       m->m_flags |= eor;

        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;
        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;


@@ -595,12 +577,13 @@ panic("sbappendaddr");
        return (1);
 }
 
        return (1);
 }
 

+int

 sbappendcontrol(sb, m0, control)
        struct sockbuf *sb;
 sbappendcontrol(sb, m0, control)
        struct sockbuf *sb;

-       struct mbuf *control, *m0;
+       struct mbuf *m0, *control;

 {
        register struct mbuf *m, *n;
 {
        register struct mbuf *m, *n;

-       int space = 0;
+       int space = 0, eor = 0;

 
        if (control == 0)
                panic("sbappendcontrol");
 
        if (control == 0)
                panic("sbappendcontrol");


@@ -615,8 +598,11 @@ sbappendcontrol(sb, m0, control)
        if (space > sbspace(sb))
                return (0);
        n->m_next = m0;                 /* concatenate data to control */
        if (space > sbspace(sb))
                return (0);
        n->m_next = m0;                 /* concatenate data to control */

-       for (m = control; m; m = m->m_next)
+       for (m = control; m; m = m->m_next) {
+               eor |= m->m_flags & M_EOR;

                sballoc(sb, m);
                sballoc(sb, m);

+       }
+       control->m_flags |= eor;

        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;
        if (n = sb->sb_mb) {
                while (n->m_nextpkt)
                        n = n->m_nextpkt;


@@ -631,23 +617,30 @@ sbappendcontrol(sb, m0, control)
  * buffer sb following mbuf n.  If n
  * is null, the buffer is presumed empty.
  */
  * buffer sb following mbuf n.  If n
  * is null, the buffer is presumed empty.
  */

-sbcompress(sb, m, n)
+void
+sbcompress(sb, m, n0)

        register struct sockbuf *sb;
        register struct sockbuf *sb;

-       register struct mbuf *m, *n;
+       register struct mbuf *m;
+       struct mbuf *n0;

 {
 {

+       register struct mbuf *n = n0;

        register int eor = 0;
        register int eor = 0;

-       register struct mbuf *o;

 
 

+       if (n) {
+               if (n->m_flags & M_EOR)
+                       n = 0;
+               else while (n->m_next)
+                       n = n->m_next;
+       }

        while (m) {
                eor |= m->m_flags & M_EOR;
        while (m) {
                eor |= m->m_flags & M_EOR;

-               if (m->m_len == 0 &&
-                   (eor == 0 ||
-                    (((o = m->m_next) || (o = n)) &&
-                     o->m_type == m->m_type))) {
-                       m = m_free(m);
-                       continue;
+               if (m->m_len == 0) {
+                       if (eor == 0 || m->m_next || n) {
+                               m = m_free(m);
+                               continue;
+                       }

                }
                }

-               if (n && (n->m_flags & (M_EXT | M_EOR)) == 0 &&
+               if (n && (n->m_flags & M_EXT) == 0 &&

                    (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
                    n->m_type == m->m_type) {
                        bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,
                    (n->m_data + n->m_len + m->m_len) < &n->m_dat[MLEN] &&
                    n->m_type == m->m_type) {
                        bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len,


@@ -657,21 +650,25 @@ sbcompress(sb, m, n)
                        m = m_free(m);
                        continue;
                }
                        m = m_free(m);
                        continue;
                }

-               if (n)
+               if (n == 0) {
+                       if (n0)
+                               n0->m_nextpkt = m;
+                       else
+                               sb->sb_mb = m;
+                       n0 = m;
+               } else

                        n->m_next = m;
                        n->m_next = m;

-               else
-                       sb->sb_mb = m;

                sballoc(sb, m);
                n = m;
                sballoc(sb, m);
                n = m;

-               m->m_flags &= ~M_EOR;
+               /*m->m_flags &= ~M_EOR;*/

                m = m->m_next;
                n->m_next = 0;
        }
        if (eor) {
                m = m->m_next;
                n->m_next = 0;
        }
        if (eor) {

-               if (n)
-                       n->m_flags |= eor;
+               if (n0)
+                       n0->m_flags |= eor;

                else
                else

-                       printf("semi-panic: sbcompress\n");
+                       panic("sbcompress");

        }
 }
 
        }
 }
 


@@ -679,6 +676,7 @@ sbcompress(sb, m, n)
  * Free all mbufs in a sockbuf.
  * Check that all resources are reclaimed.
  */
  * Free all mbufs in a sockbuf.
  * Check that all resources are reclaimed.
  */

+void

 sbflush(sb)
        register struct sockbuf *sb;
 {
 sbflush(sb)
        register struct sockbuf *sb;
 {


@@ -694,6 +692,7 @@ sbflush(sb)
 /*
  * Drop data from (the front of) a sockbuf.
  */
 /*
  * Drop data from (the front of) a sockbuf.
  */

+void

 sbdrop(sb, len)
        register struct sockbuf *sb;
        register int len;
 sbdrop(sb, len)
        register struct sockbuf *sb;
        register int len;


@@ -737,6 +736,7 @@ sbdrop(sb, len)
  * Drop a record off the front of a sockbuf
  * and move the next record to the front.
  */
  * Drop a record off the front of a sockbuf
  * and move the next record to the front.
  */

+void

 sbdroprecord(sb)
        register struct sockbuf *sb;
 {
 sbdroprecord(sb)
        register struct sockbuf *sb;
 {