[BACK]Return to uipc_socket.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/kern/uipc_socket.c between version 1.90 and 1.99

version 1.90, 2003/09/22 12:59:58 version 1.99, 2004/04/22 01:01:40
Line 126  void
Line 126  void
 soinit(void)  soinit(void)
 {  {
   
           /* Set the initial adjusted socket buffer size. */
           if (sb_max_set(sb_max))
                   panic("bad initial sb_max value: %lu\n", sb_max);
   
         pool_init(&socket_pool, sizeof(struct socket), 0, 0, 0,          pool_init(&socket_pool, sizeof(struct socket), 0, 0, 0,
             "sockpl", NULL);              "sockpl", NULL);
   
Line 143  int use_sosend_loan = 0;
Line 147  int use_sosend_loan = 0;
 int use_sosend_loan = 1;  int use_sosend_loan = 1;
 #endif  #endif
   
   struct simplelock so_pendfree_slock = SIMPLELOCK_INITIALIZER;
 struct mbuf *so_pendfree;  struct mbuf *so_pendfree;
   
 #ifndef SOMAXKVA  #ifndef SOMAXKVA
Line 156  int sokvawaiters;
Line 161  int sokvawaiters;
 #define SOCK_LOAN_CHUNK         65536  #define SOCK_LOAN_CHUNK         65536
   
 static size_t sodopendfree(struct socket *);  static size_t sodopendfree(struct socket *);
   static size_t sodopendfreel(struct socket *);
   static __inline vsize_t sokvareserve(struct socket *, vsize_t);
   static __inline void sokvaunreserve(vsize_t);
   
 vaddr_t  static __inline vsize_t
 sokvaalloc(vsize_t len, struct socket *so)  sokvareserve(struct socket *so, vsize_t len)
 {  {
         vaddr_t lva;  
         int s;          int s;
           int error;
   
           s = splvm();
           simple_lock(&so_pendfree_slock);
         while (socurkva + len > somaxkva) {          while (socurkva + len > somaxkva) {
                 if (sodopendfree(so))                  size_t freed;
   
                   /*
                    * try to do pendfree.
                    */
   
                   freed = sodopendfreel(so);
   
                   /*
                    * if some kva was freed, try again.
                    */
   
                   if (freed)
                         continue;                          continue;
   
                 SOSEND_COUNTER_INCR(&sosend_kvalimit);                  SOSEND_COUNTER_INCR(&sosend_kvalimit);
                 s = splvm();  
                 sokvawaiters++;                  sokvawaiters++;
                 (void) tsleep(&socurkva, PVM, "sokva", 0);                  error = ltsleep(&socurkva, PVM | PCATCH, "sokva", 0,
                       &so_pendfree_slock);
                 sokvawaiters--;                  sokvawaiters--;
                 splx(s);                  if (error) {
                           len = 0;
                           break;
                   }
         }          }
           socurkva += len;
           simple_unlock(&so_pendfree_slock);
           splx(s);
           return len;
   }
   
   static __inline void
   sokvaunreserve(vsize_t len)
   {
           int s;
   
           s = splvm();
           simple_lock(&so_pendfree_slock);
           socurkva -= len;
           if (sokvawaiters)
                   wakeup(&socurkva);
           simple_unlock(&so_pendfree_slock);
           splx(s);
   }
   
   /*
    * sokvaalloc: allocate kva for loan.
    */
   
   vaddr_t
   sokvaalloc(vsize_t len, struct socket *so)
   {
           vaddr_t lva;
   
           /*
            * reserve kva.
            */
   
           if (sokvareserve(so, len) == 0)
                   return 0;
   
           /*
            * allocate kva.
            */
   
         lva = uvm_km_valloc_wait(kernel_map, len);          lva = uvm_km_valloc_wait(kernel_map, len);
         if (lva == 0)          if (lva == 0) {
                   sokvaunreserve(len);
                 return (0);                  return (0);
         socurkva += len;          }
   
         return lva;          return lva;
 }  }
   
   /*
    * sokvafree: free kva for loan.
    */
   
 void  void
 sokvafree(vaddr_t sva, vsize_t len)  sokvafree(vaddr_t sva, vsize_t len)
 {  {
   
           /*
            * free kva.
            */
   
         uvm_km_free(kernel_map, sva, len);          uvm_km_free(kernel_map, sva, len);
         socurkva -= len;  
         if (sokvawaiters)          /*
                 wakeup(&socurkva);           * unreserve kva.
            */
   
           sokvaunreserve(len);
 }  }
   
 static void  static void
Line 224  sodoloanfree(struct vm_page **pgs, caddr
Line 301  sodoloanfree(struct vm_page **pgs, caddr
 static size_t  static size_t
 sodopendfree(struct socket *so)  sodopendfree(struct socket *so)
 {  {
         struct mbuf *m;  
         size_t rv = 0;  
         int s;          int s;
           size_t rv;
   
         s = splvm();          s = splvm();
           simple_lock(&so_pendfree_slock);
           rv = sodopendfreel(so);
           simple_unlock(&so_pendfree_slock);
           splx(s);
   
         for (;;) {          return rv;
                 m = so_pendfree;  }
                 if (m == NULL)  
                         break;  
                 so_pendfree = m->m_next;  
                 splx(s);  
   
                 rv += m->m_ext.ext_size;  /*
                 sodoloanfree((m->m_flags & M_EXT_PAGES) ?   * sodopendfreel: free mbufs on "pendfree" list.
                     m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,   * unlock and relock so_pendfree_slock when freeing mbufs.
                     m->m_ext.ext_size);   *
                 s = splvm();   * => called with so_pendfree_slock held.
                 pool_cache_put(&mbpool_cache, m);   * => called at splvm.
         }   */
   
   static size_t
   sodopendfreel(struct socket *so)
   {
           size_t rv = 0;
   
           LOCK_ASSERT(simple_lock_held(&so_pendfree_slock));
   
         for (;;) {          for (;;) {
                 m = so->so_pendfree;                  struct mbuf *m;
                   struct mbuf *next;
   
                   m = so_pendfree;
                 if (m == NULL)                  if (m == NULL)
                         break;                          break;
                 so->so_pendfree = m->m_next;                  so_pendfree = NULL;
                 splx(s);                  simple_unlock(&so_pendfree_slock);
                   /* XXX splx */
   
                   for (; m != NULL; m = next) {
                           next = m->m_next;
   
                           rv += m->m_ext.ext_size;
                           sodoloanfree((m->m_flags & M_EXT_PAGES) ?
                               m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,
                               m->m_ext.ext_size);
                           pool_cache_put(&mbpool_cache, m);
                   }
   
                 rv += m->m_ext.ext_size;                  /* XXX splvm */
                 sodoloanfree((m->m_flags & M_EXT_PAGES) ?                  simple_lock(&so_pendfree_slock);
                     m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,  
                     m->m_ext.ext_size);  
                 s = splvm();  
                 pool_cache_put(&mbpool_cache, m);  
         }          }
   
         splx(s);  
         return (rv);          return (rv);
 }  }
   
 void  void
 soloanfree(struct mbuf *m, caddr_t buf, size_t size, void *arg)  soloanfree(struct mbuf *m, caddr_t buf, size_t size, void *arg)
 {  {
         struct socket *so = arg;  
         int s;          int s;
   
         if (m == NULL) {          if (m == NULL) {
   
                   /*
                    * called from MEXTREMOVE.
                    */
   
                 sodoloanfree(NULL, buf, size);                  sodoloanfree(NULL, buf, size);
                 return;                  return;
         }          }
   
           /*
            * postpone freeing mbuf.
            *
            * we can't do it in interrupt context
            * because we need to put kva back to kernel_map.
            */
   
         s = splvm();          s = splvm();
         m->m_next = so->so_pendfree;          simple_lock(&so_pendfree_slock);
         so->so_pendfree = m;          m->m_next = so_pendfree;
         splx(s);          so_pendfree = m;
         if (sokvawaiters)          if (sokvawaiters)
                 wakeup(&socurkva);                  wakeup(&socurkva);
           simple_unlock(&so_pendfree_slock);
           splx(s);
 }  }
   
 static long  static long
Line 353  int
Line 458  int
 socreate(int dom, struct socket **aso, int type, int proto)  socreate(int dom, struct socket **aso, int type, int proto)
 {  {
         struct proc     *p;          struct proc     *p;
         struct protosw  *prp;          const struct protosw    *prp;
         struct socket   *so;          struct socket   *so;
         int             error, s;          int             error, s;
   
Line 382  socreate(int dom, struct socket **aso, i
Line 487  socreate(int dom, struct socket **aso, i
 #endif  #endif
         if (p != 0)          if (p != 0)
                 so->so_uid = p->p_ucred->cr_uid;                  so->so_uid = p->p_ucred->cr_uid;
           else
                   so->so_uid = UID_MAX;
         error = (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,          error = (*prp->pr_usrreq)(so, PRU_ATTACH, (struct mbuf *)0,
             (struct mbuf *)(long)proto, (struct mbuf *)0, p);              (struct mbuf *)(long)proto, (struct mbuf *)0, p);
         if (error) {          if (error) {
Line 431  solisten(struct socket *so, int backlog)
Line 538  solisten(struct socket *so, int backlog)
 void  void
 sofree(struct socket *so)  sofree(struct socket *so)
 {  {
         struct mbuf *m;  
   
         if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)          if (so->so_pcb || (so->so_state & SS_NOFDREF) == 0)
                 return;                  return;
Line 444  sofree(struct socket *so)
Line 550  sofree(struct socket *so)
                 if (!soqremque(so, 0))                  if (!soqremque(so, 0))
                         return;                          return;
         }          }
         sbrelease(&so->so_snd);          if (so->so_rcv.sb_hiwat)
                   (void)chgsbsize(so->so_uid, &so->so_rcv.sb_hiwat, 0,
                       RLIM_INFINITY);
           if (so->so_snd.sb_hiwat)
                   (void)chgsbsize(so->so_uid, &so->so_snd.sb_hiwat, 0,
                       RLIM_INFINITY);
           sbrelease(&so->so_snd, so);
         sorflush(so);          sorflush(so);
         while ((m = so->so_pendfree) != NULL) {  
                 so->so_pendfree = m->m_next;  
                 m->m_next = so_pendfree;  
                 so_pendfree = m;  
         }  
         pool_put(&socket_pool, so);          pool_put(&socket_pool, so);
 }  }
   
Line 692  sosend(struct socket *so, struct mbuf *a
Line 799  sosend(struct socket *so, struct mbuf *a
                 if ((atomic && resid > so->so_snd.sb_hiwat) ||                  if ((atomic && resid > so->so_snd.sb_hiwat) ||
                     clen > so->so_snd.sb_hiwat)                      clen > so->so_snd.sb_hiwat)
                         snderr(EMSGSIZE);                          snderr(EMSGSIZE);
                 if (space < resid + clen && uio &&                  if (space < resid + clen &&
                     (atomic || space < so->so_snd.sb_lowat || space < clen)) {                      (atomic || space < so->so_snd.sb_lowat || space < clen)) {
                         if (so->so_state & SS_NBIO)                          if (so->so_state & SS_NBIO)
                                 snderr(EWOULDBLOCK);                                  snderr(EWOULDBLOCK);
Line 835  soreceive(struct socket *so, struct mbuf
Line 942  soreceive(struct socket *so, struct mbuf
 {  {
         struct mbuf     *m, **mp;          struct mbuf     *m, **mp;
         int             flags, len, error, s, offset, moff, type, orig_resid;          int             flags, len, error, s, offset, moff, type, orig_resid;
         struct protosw  *pr;          const struct protosw    *pr;
         struct mbuf     *nextrecord;          struct mbuf     *nextrecord;
         int             mbuf_removed = 0;          int             mbuf_removed = 0;
   
Line 1238  soreceive(struct socket *so, struct mbuf
Line 1345  soreceive(struct socket *so, struct mbuf
 int  int
 soshutdown(struct socket *so, int how)  soshutdown(struct socket *so, int how)
 {  {
         struct protosw  *pr;          const struct protosw    *pr;
   
         pr = so->so_proto;          pr = so->so_proto;
         if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))          if (!(how == SHUT_RD || how == SHUT_WR || how == SHUT_RDWR))
Line 1256  void
Line 1363  void
 sorflush(struct socket *so)  sorflush(struct socket *so)
 {  {
         struct sockbuf  *sb, asb;          struct sockbuf  *sb, asb;
         struct protosw  *pr;          const struct protosw    *pr;
         int             s;          int             s;
   
         sb = &so->so_rcv;          sb = &so->so_rcv;
Line 1276  sorflush(struct socket *so)
Line 1383  sorflush(struct socket *so)
         splx(s);          splx(s);
         if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)          if (pr->pr_flags & PR_RIGHTS && pr->pr_domain->dom_dispose)
                 (*pr->pr_domain->dom_dispose)(asb.sb_mb);                  (*pr->pr_domain->dom_dispose)(asb.sb_mb);
         sbrelease(&asb);          sbrelease(&asb, so);
 }  }
   
 int  int
Line 1350  sosetopt(struct socket *so, int level, i
Line 1457  sosetopt(struct socket *so, int level, i
                         case SO_RCVBUF:                          case SO_RCVBUF:
                                 if (sbreserve(optname == SO_SNDBUF ?                                  if (sbreserve(optname == SO_SNDBUF ?
                                     &so->so_snd : &so->so_rcv,                                      &so->so_snd : &so->so_rcv,
                                     (u_long) optval) == 0) {                                      (u_long) optval, so) == 0) {
                                         error = ENOBUFS;                                          error = ENOBUFS;
                                         goto bad;                                          goto bad;
                                 }                                  }
Line 1626  soo_kqfilter(struct file *fp, struct kno
Line 1733  soo_kqfilter(struct file *fp, struct kno
         return (0);          return (0);
 }  }
   
   #include <sys/sysctl.h>
   
   static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
   
   /*
    * sysctl helper routine for kern.somaxkva.  ensures that the given
    * value is not too small.
    * (XXX should we maybe make sure it's not too large as well?)
    */
   static int
   sysctl_kern_somaxkva(SYSCTLFN_ARGS)
   {
           int error, new_somaxkva;
           struct sysctlnode node;
           int s;
   
           new_somaxkva = somaxkva;
           node = *rnode;
           node.sysctl_data = &new_somaxkva;
           error = sysctl_lookup(SYSCTLFN_CALL(&node));
           if (error || newp == NULL)
                   return (error);
   
           if (new_somaxkva < (16 * 1024 * 1024)) /* sanity */
                   return (EINVAL);
   
           s = splvm();
           simple_lock(&so_pendfree_slock);
           somaxkva = new_somaxkva;
           wakeup(&socurkva);
           simple_unlock(&so_pendfree_slock);
           splx(s);
   
           return (error);
   }
   
   SYSCTL_SETUP(sysctl_kern_somaxkva_setup, "sysctl kern.somaxkva setup")
   {
   
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT,
                          CTLTYPE_NODE, "kern", NULL,
                          NULL, 0, NULL, 0,
                          CTL_KERN, CTL_EOL);
   
           sysctl_createv(clog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "somaxkva", NULL,
                          sysctl_kern_somaxkva, 0, NULL, 0,
                          CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
   }

Legend:
Removed from v.1.90  
changed lines
  Added in v.1.99

CVSweb <webmaster@jp.NetBSD.org>