[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.111.2.15 and 1.141.2.1

version 1.111.2.15, 2008/03/24 09:39:02 version 1.141.2.1, 2007/11/06 23:32:41
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 2002, 2007, 2008 The NetBSD Foundation, Inc.   * Copyright (c) 2002, 2007 The NetBSD Foundation, Inc.
  * All rights reserved.   * All rights reserved.
  *   *
  * This code is derived from software contributed to The NetBSD Foundation   * This code is derived from software contributed to The NetBSD Foundation
Line 253  sokvafree(vaddr_t sva, vsize_t len)
Line 253  sokvafree(vaddr_t sva, vsize_t len)
 static void  static void
 sodoloanfree(struct vm_page **pgs, void *buf, size_t size)  sodoloanfree(struct vm_page **pgs, void *buf, size_t size)
 {  {
         vaddr_t sva, eva;          vaddr_t va, sva, eva;
         vsize_t len;          vsize_t len;
         int npgs;          paddr_t pa;
           int i, npgs;
         KASSERT(pgs != NULL);  
   
         eva = round_page((vaddr_t) buf + size);          eva = round_page((vaddr_t) buf + size);
         sva = trunc_page((vaddr_t) buf);          sva = trunc_page((vaddr_t) buf);
         len = eva - sva;          len = eva - sva;
         npgs = len >> PAGE_SHIFT;          npgs = len >> PAGE_SHIFT;
   
           if (__predict_false(pgs == NULL)) {
                   pgs = alloca(npgs * sizeof(*pgs));
   
                   for (i = 0, va = sva; va < eva; i++, va += PAGE_SIZE) {
                           if (pmap_extract(pmap_kernel(), va, &pa) == false)
                                   panic("sodoloanfree: va 0x%lx not mapped", va);
                           pgs[i] = PHYS_TO_VM_PAGE(pa);
                   }
           }
   
         pmap_kremove(sva, len);          pmap_kremove(sva, len);
         pmap_update(pmap_kernel());          pmap_update(pmap_kernel());
         uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);          uvm_unloan(pgs, npgs, UVM_LOAN_TOPAGE);
Line 271  sodoloanfree(struct vm_page **pgs, void 
Line 280  sodoloanfree(struct vm_page **pgs, void 
 }  }
   
 static size_t  static size_t
 sodopendfree(void)  sodopendfree()
 {  {
         size_t rv;          size_t rv;
   
Line 290  sodopendfree(void)
Line 299  sodopendfree(void)
  */   */
   
 static size_t  static size_t
 sodopendfreel(void)  sodopendfreel()
 {  {
         struct mbuf *m, *next;          struct mbuf *m, *next;
         size_t rv = 0;          size_t rv = 0;
           int s;
   
         KASSERT(mutex_owned(&so_pendfree_lock));          KASSERT(mutex_owned(&so_pendfree_lock));
   
Line 304  sodopendfreel(void)
Line 314  sodopendfreel(void)
   
                 for (; m != NULL; m = next) {                  for (; m != NULL; m = next) {
                         next = m->m_next;                          next = m->m_next;
                         KASSERT((~m->m_flags & (M_EXT|M_EXT_PAGES)) == 0);  
                         KASSERT(m->m_ext.ext_refcnt == 0);  
   
                         rv += m->m_ext.ext_size;                          rv += m->m_ext.ext_size;
                         sodoloanfree(m->m_ext.ext_pgs, m->m_ext.ext_buf,                          sodoloanfree((m->m_flags & M_EXT_PAGES) ?
                               m->m_ext.ext_pgs : NULL, m->m_ext.ext_buf,
                             m->m_ext.ext_size);                              m->m_ext.ext_size);
                         pool_cache_put(mb_cache, m);                          s = splvm();
                           pool_cache_put(&mbpool_cache, m);
                           splx(s);
                 }                  }
   
                 mutex_enter(&so_pendfree_lock);                  mutex_enter(&so_pendfree_lock);
Line 323  void
Line 334  void
 soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)  soloanfree(struct mbuf *m, void *buf, size_t size, void *arg)
 {  {
   
         KASSERT(m != NULL);          if (m == NULL) {
   
                   /*
                    * called from MEXTREMOVE.
                    */
   
                   sodoloanfree(NULL, buf, size);
                   return;
           }
   
         /*          /*
          * postpone freeing mbuf.           * postpone freeing mbuf.
Line 345  sosend_loan(struct socket *so, struct ui
Line 364  sosend_loan(struct socket *so, struct ui
         struct iovec *iov = uio->uio_iov;          struct iovec *iov = uio->uio_iov;
         vaddr_t sva, eva;          vaddr_t sva, eva;
         vsize_t len;          vsize_t len;
         vaddr_t lva;          vaddr_t lva, va;
         int npgs, error;          int npgs, i, error;
         vaddr_t va;  
         int i;  
   
         if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))          if (VMSPACE_IS_KERNEL_P(uio->uio_vmspace))
                 return (0);                  return (0);
Line 414  sokva_reclaim_callback(struct callback_e
Line 431  sokva_reclaim_callback(struct callback_e
 }  }
   
 struct mbuf *  struct mbuf *
 getsombuf(struct socket *so, int type)  getsombuf(struct socket *so)
 {  {
         struct mbuf *m;          struct mbuf *m;
   
         m = m_get(M_WAIT, type);          m = m_get(M_WAIT, MT_SONAME);
         MCLAIM(m, so->so_mowner);          MCLAIM(m, so->so_mowner);
         return m;          return m;
 }  }
Line 428  m_intopt(struct socket *so, int val)
Line 445  m_intopt(struct socket *so, int val)
 {  {
         struct mbuf *m;          struct mbuf *m;
   
         m = getsombuf(so, MT_SOOPTS);          m = getsombuf(so);
         m->m_len = sizeof(int);          m->m_len = sizeof(int);
         *mtod(m, int *) = val;          *mtod(m, int *) = val;
         return m;          return m;
Line 438  void
Line 455  void
 soinit(void)  soinit(void)
 {  {
   
         mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);          mutex_init(&so_pendfree_lock, MUTEX_DRIVER, IPL_VM);
         cv_init(&socurkva_cv, "sokva");          cv_init(&socurkva_cv, "sokva");
   
         /* Set the initial adjusted socket buffer size. */          /* Set the initial adjusted socket buffer size. */
Line 526  int
Line 543  int
 fsocreate(int domain, struct socket **sop, int type, int protocol,  fsocreate(int domain, struct socket **sop, int type, int protocol,
     struct lwp *l, int *fdout)      struct lwp *l, int *fdout)
 {  {
           struct filedesc *fdp;
         struct socket   *so;          struct socket   *so;
         struct file     *fp;          struct file     *fp;
         int             fd, error;          int             fd, error;
   
         if ((error = fd_allocfile(&fp, &fd)) != 0)          fdp = l->l_proc->p_fd;
           /* falloc() will use the desciptor for us */
           if ((error = falloc(l, &fp, &fd)) != 0)
                 return (error);                  return (error);
         fp->f_flag = FREAD|FWRITE;          fp->f_flag = FREAD|FWRITE;
         fp->f_type = DTYPE_SOCKET;          fp->f_type = DTYPE_SOCKET;
         fp->f_ops = &socketops;          fp->f_ops = &socketops;
         error = socreate(domain, &so, type, protocol, l);          error = socreate(domain, &so, type, protocol, l);
         if (error != 0) {          if (error != 0) {
                 fd_abort(curproc, fp, fd);                  FILE_UNUSE(fp, l);
                   fdremove(fdp, fd);
                   ffree(fp);
         } else {          } else {
                 if (sop != NULL)                  if (sop != NULL)
                         *sop = so;                          *sop = so;
                 fp->f_data = so;                  fp->f_data = so;
                 fd_affix(curproc, fp, fd);                  FILE_SET_MATURE(fp);
                   FILE_UNUSE(fp, l);
                 *fdout = fd;                  *fdout = fd;
         }          }
         return error;          return error;
Line 560  sobind(struct socket *so, struct mbuf *n
Line 583  sobind(struct socket *so, struct mbuf *n
 }  }
   
 int  int
 solisten(struct socket *so, int backlog, struct lwp *l)  solisten(struct socket *so, int backlog)
 {  {
         int     s, error;          int     s, error;
   
         s = splsoftnet();          s = splsoftnet();
         error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,          error = (*so->so_proto->pr_usrreq)(so, PRU_LISTEN, NULL,
             NULL, NULL, l);              NULL, NULL, NULL);
         if (error != 0) {          if (error != 0) {
                 splx(s);                  splx(s);
                 return error;                  return error;
Line 640  soclose(struct socket *so)
Line 663  soclose(struct socket *so)
                                 goto drop;                                  goto drop;
                 }                  }
                 if (so->so_options & SO_LINGER) {                  if (so->so_options & SO_LINGER) {
                         if ((so->so_state & SS_ISDISCONNECTING) && so->so_nbio)                          if ((so->so_state & SS_ISDISCONNECTING) &&
                               (so->so_state & SS_NBIO))
                                 goto drop;                                  goto drop;
                         while (so->so_state & SS_ISCONNECTED) {                          while (so->so_state & SS_ISCONNECTED) {
                                 error = tsleep((void *)&so->so_timeo,                                  error = tsleep((void *)&so->so_timeo,
Line 849  sosend(struct socket *so, struct mbuf *a
Line 873  sosend(struct socket *so, struct mbuf *a
                         snderr(EMSGSIZE);                          snderr(EMSGSIZE);
                 if (space < resid + clen &&                  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_nbio)                          if (so->so_state & SS_NBIO)
                                 snderr(EWOULDBLOCK);                                  snderr(EWOULDBLOCK);
                         sbunlock(&so->so_snd);                          sbunlock(&so->so_snd);
                         error = sbwait(&so->so_snd);                          error = sbwait(&so->so_snd);
Line 989  soreceive(struct socket *so, struct mbuf
Line 1013  soreceive(struct socket *so, struct mbuf
 {  {
         struct lwp *l = curlwp;          struct lwp *l = curlwp;
         struct mbuf     *m, **mp;          struct mbuf     *m, **mp;
         int atomic, flags, len, error, s, offset, moff, type, orig_resid;          int             flags, len, error, s, offset, moff, type, orig_resid;
         const struct protosw    *pr;          const struct protosw    *pr;
         struct mbuf     *nextrecord;          struct mbuf     *nextrecord;
         int             mbuf_removed = 0;          int             mbuf_removed = 0;
         const struct domain *dom;  
   
         pr = so->so_proto;          pr = so->so_proto;
         atomic = pr->pr_flags & PR_ATOMIC;  
         dom = pr->pr_domain;  
         mp = mp0;          mp = mp0;
         type = 0;          type = 0;
         orig_resid = uio->uio_resid;          orig_resid = uio->uio_resid;
Line 1058  soreceive(struct socket *so, struct mbuf
Line 1079  soreceive(struct socket *so, struct mbuf
              (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||               (so->so_rcv.sb_cc < so->so_rcv.sb_lowat ||
               ((flags & MSG_WAITALL) &&                ((flags & MSG_WAITALL) &&
                uio->uio_resid <= so->so_rcv.sb_hiwat)) &&                 uio->uio_resid <= so->so_rcv.sb_hiwat)) &&
              m->m_nextpkt == NULL && !atomic)) {               m->m_nextpkt == NULL &&
                (pr->pr_flags & PR_ATOMIC) == 0)) {
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
                 if (m == NULL && so->so_rcv.sb_cc)                  if (m == NULL && so->so_rcv.sb_cc)
                         panic("receive 1");                          panic("receive 1");
Line 1089  soreceive(struct socket *so, struct mbuf
Line 1111  soreceive(struct socket *so, struct mbuf
                 }                  }
                 if (uio->uio_resid == 0)                  if (uio->uio_resid == 0)
                         goto release;                          goto release;
                 if (so->so_nbio || (flags & MSG_DONTWAIT)) {                  if ((so->so_state & SS_NBIO) || (flags & MSG_DONTWAIT)) {
                         error = EWOULDBLOCK;                          error = EWOULDBLOCK;
                         goto release;                          goto release;
                 }                  }
Line 1147  soreceive(struct socket *so, struct mbuf
Line 1169  soreceive(struct socket *so, struct mbuf
                         sbfree(&so->so_rcv, m);                          sbfree(&so->so_rcv, m);
                         mbuf_removed = 1;                          mbuf_removed = 1;
                         if (controlp != NULL) {                          if (controlp != NULL) {
                                   struct domain *dom = pr->pr_domain;
                                 if (dom->dom_externalize && l &&                                  if (dom->dom_externalize && l &&
                                     mtod(m, struct cmsghdr *)->cmsg_type ==                                      mtod(m, struct cmsghdr *)->cmsg_type ==
                                     SCM_RIGHTS)                                      SCM_RIGHTS)
Line 1160  soreceive(struct socket *so, struct mbuf
Line 1183  soreceive(struct socket *so, struct mbuf
                                  * Dispose of any SCM_RIGHTS message that went                                   * Dispose of any SCM_RIGHTS message that went
                                  * through the read path rather than recv.                                   * through the read path rather than recv.
                                  */                                   */
                                 if (dom->dom_dispose &&                                  if (pr->pr_domain->dom_dispose &&
                                     mtod(m, struct cmsghdr *)->cmsg_type == SCM_RIGHTS)                                      mtod(m, struct cmsghdr *)->cmsg_type == SCM_RIGHTS)
                                         (*dom->dom_dispose)(m);                                          (*pr->pr_domain->dom_dispose)(m);
                                 MFREE(m, so->so_rcv.sb_mb);                                  MFREE(m, so->so_rcv.sb_mb);
                                 m = so->so_rcv.sb_mb;                                  m = so->so_rcv.sb_mb;
                         }                          }
Line 1249  soreceive(struct socket *so, struct mbuf
Line 1272  soreceive(struct socket *so, struct mbuf
                                  * This avoids a later panic("receive 1a")                                   * This avoids a later panic("receive 1a")
                                  * when compiled with DIAGNOSTIC.                                   * when compiled with DIAGNOSTIC.
                                  */                                   */
                                 if (m && mbuf_removed && atomic)                                  if (m && mbuf_removed
                                       && (pr->pr_flags & PR_ATOMIC))
                                         (void) sbdroprecord(&so->so_rcv);                                          (void) sbdroprecord(&so->so_rcv);
   
                                 goto release;                                  goto release;
Line 1352  soreceive(struct socket *so, struct mbuf
Line 1376  soreceive(struct socket *so, struct mbuf
                 }                  }
         }          }
   
         if (m && atomic) {          if (m && pr->pr_flags & PR_ATOMIC) {
                 flags |= MSG_TRUNC;                  flags |= MSG_TRUNC;
                 if ((flags & MSG_PEEK) == 0)                  if ((flags & MSG_PEEK) == 0)
                         (void) sbdroprecord(&so->so_rcv);                          (void) sbdroprecord(&so->so_rcv);
Line 1662  sogetopt(struct socket *so, int level, i
Line 1686  sogetopt(struct socket *so, int level, i
 void  void
 sohasoutofband(struct socket *so)  sohasoutofband(struct socket *so)
 {  {
   
         fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);          fownsignal(so->so_pgid, SIGURG, POLL_PRI, POLLPRI|POLLRDBAND, so);
         selnotify(&so->so_rcv.sb_sel, POLLPRI | POLLRDBAND, 0);          selwakeup(&so->so_rcv.sb_sel);
 }  }
   
 static void  static void
Line 1672  filt_sordetach(struct knote *kn)
Line 1695  filt_sordetach(struct knote *kn)
 {  {
         struct socket   *so;          struct socket   *so;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
         SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);          SLIST_REMOVE(&so->so_rcv.sb_sel.sel_klist, kn, knote, kn_selnext);
         if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))          if (SLIST_EMPTY(&so->so_rcv.sb_sel.sel_klist))
                 so->so_rcv.sb_flags &= ~SB_KNOTE;                  so->so_rcv.sb_flags &= ~SB_KNOTE;
Line 1684  filt_soread(struct knote *kn, long hint)
Line 1707  filt_soread(struct knote *kn, long hint)
 {  {
         struct socket   *so;          struct socket   *so;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
         kn->kn_data = so->so_rcv.sb_cc;          kn->kn_data = so->so_rcv.sb_cc;
         if (so->so_state & SS_CANTRCVMORE) {          if (so->so_state & SS_CANTRCVMORE) {
                 kn->kn_flags |= EV_EOF;                  kn->kn_flags |= EV_EOF;
Line 1703  filt_sowdetach(struct knote *kn)
Line 1726  filt_sowdetach(struct knote *kn)
 {  {
         struct socket   *so;          struct socket   *so;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
         SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);          SLIST_REMOVE(&so->so_snd.sb_sel.sel_klist, kn, knote, kn_selnext);
         if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))          if (SLIST_EMPTY(&so->so_snd.sb_sel.sel_klist))
                 so->so_snd.sb_flags &= ~SB_KNOTE;                  so->so_snd.sb_flags &= ~SB_KNOTE;
Line 1715  filt_sowrite(struct knote *kn, long hint
Line 1738  filt_sowrite(struct knote *kn, long hint
 {  {
         struct socket   *so;          struct socket   *so;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
         kn->kn_data = sbspace(&so->so_snd);          kn->kn_data = sbspace(&so->so_snd);
         if (so->so_state & SS_CANTSENDMORE) {          if (so->so_state & SS_CANTSENDMORE) {
                 kn->kn_flags |= EV_EOF;                  kn->kn_flags |= EV_EOF;
Line 1738  filt_solisten(struct knote *kn, long hin
Line 1761  filt_solisten(struct knote *kn, long hin
 {  {
         struct socket   *so;          struct socket   *so;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
   
         /*          /*
          * Set kn_data to number of incoming connections, not           * Set kn_data to number of incoming connections, not
Line 1761  soo_kqfilter(struct file *fp, struct kno
Line 1784  soo_kqfilter(struct file *fp, struct kno
         struct socket   *so;          struct socket   *so;
         struct sockbuf  *sb;          struct sockbuf  *sb;
   
         so = ((file_t *)kn->kn_obj)->f_data;          so = (struct socket *)kn->kn_fp->f_data;
         switch (kn->kn_filter) {          switch (kn->kn_filter) {
         case EVFILT_READ:          case EVFILT_READ:
                 if (so->so_options & SO_ACCEPTCONN)                  if (so->so_options & SO_ACCEPTCONN)
Line 1775  soo_kqfilter(struct file *fp, struct kno
Line 1798  soo_kqfilter(struct file *fp, struct kno
                 sb = &so->so_snd;                  sb = &so->so_snd;
                 break;                  break;
         default:          default:
                 return (EINVAL);                  return (1);
         }          }
         SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);          SLIST_INSERT_HEAD(&sb->sb_sel.sel_klist, kn, kn_selnext);
         sb->sb_flags |= SB_KNOTE;          sb->sb_flags |= SB_KNOTE;
         return (0);          return (0);
 }  }
   
 static int  
 sodopoll(struct socket *so, int events)  
 {  
         int revents;  
   
         revents = 0;  
   
         if (events & (POLLIN | POLLRDNORM))  
                 if (soreadable(so))  
                         revents |= events & (POLLIN | POLLRDNORM);  
   
         if (events & (POLLOUT | POLLWRNORM))  
                 if (sowritable(so))  
                         revents |= events & (POLLOUT | POLLWRNORM);  
   
         if (events & (POLLPRI | POLLRDBAND))  
                 if (so->so_oobmark || (so->so_state & SS_RCVATMARK))  
                         revents |= events & (POLLPRI | POLLRDBAND);  
   
         return revents;  
 }  
   
 int  
 sopoll(struct socket *so, int events)  
 {  
         int revents = 0;  
         int s;  
   
         if ((revents = sodopoll(so, events)) != 0)  
                 return revents;  
   
         KERNEL_LOCK(1, curlwp);  
         s = splsoftnet();  
   
         if ((revents = sodopoll(so, events)) == 0) {  
                 if (events & (POLLIN | POLLPRI | POLLRDNORM | POLLRDBAND)) {  
                         selrecord(curlwp, &so->so_rcv.sb_sel);  
                         so->so_rcv.sb_flags |= SB_SEL;  
                 }  
   
                 if (events & (POLLOUT | POLLWRNORM)) {  
                         selrecord(curlwp, &so->so_snd.sb_sel);  
                         so->so_snd.sb_flags |= SB_SEL;  
                 }  
         }  
   
         splx(s);  
         KERNEL_UNLOCK_ONE(curlwp);  
   
         return revents;  
 }  
   
   
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);  static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);

Legend:
Removed from v.1.111.2.15  
changed lines
  Added in v.1.141.2.1

CVSweb <webmaster@jp.NetBSD.org>