[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.209.2.2 and 1.211.2.3

version 1.209.2.2, 2013/02/14 22:13:59 version 1.211.2.3, 2013/06/23 06:18:58
Line 160  static void sopendfree_thread(void *);
Line 160  static void sopendfree_thread(void *);
 static kcondvar_t pendfree_thread_cv;  static kcondvar_t pendfree_thread_cv;
 static lwp_t *sopendfree_lwp;  static lwp_t *sopendfree_lwp;
   
 static void sysctl_kern_somaxkva_setup(void);  static void sysctl_kern_socket_setup(void);
 static struct sysctllog *socket_sysctllog;  static struct sysctllog *socket_sysctllog;
   
 static vsize_t  static vsize_t
Line 453  void
Line 453  void
 soinit(void)  soinit(void)
 {  {
   
         sysctl_kern_somaxkva_setup();          sysctl_kern_socket_setup();
   
         mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);          mutex_init(&so_pendfree_lock, MUTEX_DEFAULT, IPL_VM);
         softnet_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);          softnet_lock = mutex_obj_alloc(MUTEX_DEFAULT, IPL_NONE);
Line 538  socreate(int dom, struct socket **aso, i
Line 538  socreate(int dom, struct socket **aso, i
                 lock = lockso->so_lock;                  lock = lockso->so_lock;
                 so->so_lock = lock;                  so->so_lock = lock;
                 mutex_obj_hold(lock);                  mutex_obj_hold(lock);
                   /* XXX Why is this not solock, to match sounlock? */
                 mutex_enter(lock);                  mutex_enter(lock);
         } else {          } else {
                 /* Lock assigned and taken during PRU_ATTACH. */                  /* Lock assigned and taken during PRU_ATTACH. */
Line 624  solisten(struct socket *so, int backlog,
Line 625  solisten(struct socket *so, int backlog,
         if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |          if ((so->so_state & (SS_ISCONNECTED | SS_ISCONNECTING |
             SS_ISDISCONNECTING)) != 0) {              SS_ISDISCONNECTING)) != 0) {
                 sounlock(so);                  sounlock(so);
                 return (EOPNOTSUPP);                  return (EINVAL);
         }          }
         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, l);
Line 876  sosend(struct socket *so, struct mbuf *a
Line 877  sosend(struct socket *so, struct mbuf *a
         struct mbuf *control, int flags, struct lwp *l)          struct mbuf *control, int flags, struct lwp *l)
 {  {
         struct mbuf     **mp, *m;          struct mbuf     **mp, *m;
         struct proc     *p;  
         long            space, len, resid, clen, mlen;          long            space, len, resid, clen, mlen;
         int             error, s, dontroute, atomic;          int             error, s, dontroute, atomic;
         short           wakeup_state = 0;          short           wakeup_state = 0;
   
         p = l->l_proc;  
         clen = 0;          clen = 0;
   
         /*          /*
Line 2368  sopoll(struct socket *so, int events)
Line 2367  sopoll(struct socket *so, int events)
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);  static int sysctl_kern_somaxkva(SYSCTLFN_PROTO);
   static int sysctl_kern_sbmax(SYSCTLFN_PROTO);
   
 /*  /*
  * sysctl helper routine for kern.somaxkva.  ensures that the given   * sysctl helper routine for kern.somaxkva.  ensures that the given
Line 2398  sysctl_kern_somaxkva(SYSCTLFN_ARGS)
Line 2398  sysctl_kern_somaxkva(SYSCTLFN_ARGS)
         return (error);          return (error);
 }  }
   
   /*
    * sysctl helper routine for kern.sbmax. Basically just ensures that
    * any new value is not too small.
    */
   static int
   sysctl_kern_sbmax(SYSCTLFN_ARGS)
   {
           int error, new_sbmax;
           struct sysctlnode node;
   
           new_sbmax = sb_max;
           node = *rnode;
           node.sysctl_data = &new_sbmax;
           error = sysctl_lookup(SYSCTLFN_CALL(&node));
           if (error || newp == NULL)
                   return (error);
   
           KERNEL_LOCK(1, NULL);
           error = sb_max_set(new_sbmax);
           KERNEL_UNLOCK_ONE(NULL);
   
           return (error);
   }
   
 static void  static void
 sysctl_kern_somaxkva_setup(void)  sysctl_kern_socket_setup(void)
 {  {
   
         KASSERT(socket_sysctllog == NULL);          KASSERT(socket_sysctllog == NULL);
Line 2416  sysctl_kern_somaxkva_setup(void)
Line 2440  sysctl_kern_somaxkva_setup(void)
                                     "used for socket buffers"),                                      "used for socket buffers"),
                        sysctl_kern_somaxkva, 0, NULL, 0,                         sysctl_kern_somaxkva, 0, NULL, 0,
                        CTL_KERN, KERN_SOMAXKVA, CTL_EOL);                         CTL_KERN, KERN_SOMAXKVA, CTL_EOL);
   
           sysctl_createv(&socket_sysctllog, 0, NULL, NULL,
                          CTLFLAG_PERMANENT|CTLFLAG_READWRITE,
                          CTLTYPE_INT, "sbmax",
                          SYSCTL_DESCR("Maximum socket buffer size"),
                          sysctl_kern_sbmax, 0, NULL, 0,
                          CTL_KERN, KERN_SBMAX, CTL_EOL);
 }  }
Legend:
Removed from v.1.209.2.2  
changed lines
  Added in v.1.211.2.3
CVSweb <webmaster@jp.NetBSD.org>