md: reduce CPU wastage on idle md array with a write-intent bitmap
[linux-2.6.git] / net / socket.c
index 156f2ef..b6d35cd 100644 (file)
  */
 
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/socket.h>
 #include <linux/file.h>
 #include <linux/net.h>
 #include <linux/interrupt.h>
+#include <linux/rcupdate.h>
 #include <linux/netdevice.h>
 #include <linux/proc_fs.h>
 #include <linux/seq_file.h>
@@ -77,7 +77,6 @@
 #include <linux/cache.h>
 #include <linux/module.h>
 #include <linux/highmem.h>
-#include <linux/divert.h>
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
@@ -85,6 +84,7 @@
 #include <linux/kmod.h>
 #include <linux/audit.h>
 #include <linux/wireless.h>
+#include <linux/nsproxy.h>
 
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include <linux/netfilter.h>
 
 static int sock_no_open(struct inode *irrelevant, struct file *dontcare);
-static ssize_t sock_aio_read(struct kiocb *iocb, char __user *buf,
-                            size_t size, loff_t pos);
-static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *buf,
-                             size_t size, loff_t pos);
+static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
+                        unsigned long nr_segs, loff_t pos);
+static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
+                         unsigned long nr_segs, loff_t pos);
 static int sock_mmap(struct file *file, struct vm_area_struct *vma);
 
 static int sock_close(struct inode *inode, struct file *file);
@@ -110,19 +110,18 @@ static long compat_sock_ioctl(struct file *file,
                              unsigned int cmd, unsigned long arg);
 #endif
 static int sock_fasync(int fd, struct file *filp, int on);
-static ssize_t sock_readv(struct file *file, const struct iovec *vector,
-                         unsigned long count, loff_t *ppos);
-static ssize_t sock_writev(struct file *file, const struct iovec *vector,
-                          unsigned long count, loff_t *ppos);
 static ssize_t sock_sendpage(struct file *file, struct page *page,
                             int offset, size_t size, loff_t *ppos, int more);
+static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
+                               struct pipe_inode_info *pipe, size_t len,
+                               unsigned int flags);
 
 /*
  *     Socket files have a set of 'special' operations as well as the generic file ones. These don't appear
  *     in the operation structures but are done directly via the socketcall() multiplexor.
  */
 
-static struct file_operations socket_file_ops = {
+static const struct file_operations socket_file_ops = {
        .owner =        THIS_MODULE,
        .llseek =       no_llseek,
        .aio_read =     sock_aio_read,
@@ -136,61 +135,17 @@ static struct file_operations socket_file_ops = {
        .open =         sock_no_open,   /* special open code to disallow open via /proc */
        .release =      sock_close,
        .fasync =       sock_fasync,
-       .readv =        sock_readv,
-       .writev =       sock_writev,
        .sendpage =     sock_sendpage,
        .splice_write = generic_splice_sendpage,
+       .splice_read =  sock_splice_read,
 };
 
 /*
  *     The protocol list. Each protocol is registered in here.
  */
 
-static struct net_proto_family *net_families[NPROTO];
-
-#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
-static atomic_t net_family_lockct = ATOMIC_INIT(0);
 static DEFINE_SPINLOCK(net_family_lock);
-
-/* The strategy is: modifications net_family vector are short, do not
-   sleep and veeery rare, but read access should be free of any exclusive
-   locks.
- */
-
-static void net_family_write_lock(void)
-{
-       spin_lock(&net_family_lock);
-       while (atomic_read(&net_family_lockct) != 0) {
-               spin_unlock(&net_family_lock);
-
-               yield();
-
-               spin_lock(&net_family_lock);
-       }
-}
-
-static __inline__ void net_family_write_unlock(void)
-{
-       spin_unlock(&net_family_lock);
-}
-
-static __inline__ void net_family_read_lock(void)
-{
-       atomic_inc(&net_family_lockct);
-       spin_unlock_wait(&net_family_lock);
-}
-
-static __inline__ void net_family_read_unlock(void)
-{
-       atomic_dec(&net_family_lockct);
-}
-
-#else
-#define net_family_write_lock() do { } while(0)
-#define net_family_write_unlock() do { } while(0)
-#define net_family_read_lock() do { } while(0)
-#define net_family_read_unlock() do { } while(0)
-#endif
+static const struct net_proto_family *net_families[NPROTO] __read_mostly;
 
 /*
  *     Statistics counters of the socket lists
@@ -280,13 +235,13 @@ int move_addr_to_user(void *kaddr, int klen, void __user *uaddr,
 
 #define SOCKFS_MAGIC 0x534F434B
 
-static kmem_cache_t *sock_inode_cachep __read_mostly;
+static struct kmem_cache *sock_inode_cachep __read_mostly;
 
 static struct inode *sock_alloc_inode(struct super_block *sb)
 {
        struct socket_alloc *ei;
 
-       ei = kmem_cache_alloc(sock_inode_cachep, SLAB_KERNEL);
+       ei = kmem_cache_alloc(sock_inode_cachep, GFP_KERNEL);
        if (!ei)
                return NULL;
        init_waitqueue_head(&ei->socket.wait);
@@ -297,7 +252,6 @@ static struct inode *sock_alloc_inode(struct super_block *sb)
        ei->socket.ops = NULL;
        ei->socket.sk = NULL;
        ei->socket.file = NULL;
-       ei->socket.flags = 0;
 
        return &ei->vfs_inode;
 }
@@ -308,13 +262,11 @@ static void sock_destroy_inode(struct inode *inode)
                        container_of(inode, struct socket_alloc, vfs_inode));
 }
 
-static void init_once(void *foo, kmem_cache_t *cachep, unsigned long flags)
+static void init_once(struct kmem_cache *cachep, void *foo)
 {
        struct socket_alloc *ei = (struct socket_alloc *)foo;
 
-       if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR))
-           == SLAB_CTOR_CONSTRUCTOR)
-               inode_init_once(&ei->vfs_inode);
+       inode_init_once(&ei->vfs_inode);
 }
 
 static int init_inodecache(void)
@@ -325,8 +277,7 @@ static int init_inodecache(void)
                                              (SLAB_HWCACHE_ALIGN |
                                               SLAB_RECLAIM_ACCOUNT |
                                               SLAB_MEM_SPREAD),
-                                             init_once,
-                                             NULL);
+                                             init_once);
        if (sock_inode_cachep == NULL)
                return -ENOMEM;
        return 0;
@@ -356,10 +307,28 @@ static struct file_system_type sock_fs_type = {
 
 static int sockfs_delete_dentry(struct dentry *dentry)
 {
-       return 1;
+       /*
+        * At creation time, we pretended this dentry was hashed
+        * (by clearing DCACHE_UNHASHED bit in d_flags)
+        * At delete time, we restore the truth : not hashed.
+        * (so that dput() can proceed correctly)
+        */
+       dentry->d_flags |= DCACHE_UNHASHED;
+       return 0;
+}
+
+/*
+ * sockfs_dname() is called from d_path().
+ */
+static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+       return dynamic_dname(dentry, buffer, buflen, "socket:[%lu]",
+                               dentry->d_inode->i_ino);
 }
+
 static struct dentry_operations sockfs_dentry_operations = {
        .d_delete = sockfs_delete_dentry,
+       .d_dname  = sockfs_dname,
 };
 
 /*
@@ -399,25 +368,26 @@ static int sock_alloc_fd(struct file **filep)
 
 static int sock_attach_fd(struct socket *sock, struct file *file)
 {
-       struct qstr this;
-       char name[32];
-
-       this.len = sprintf(name, "[%lu]", SOCK_INODE(sock)->i_ino);
-       this.name = name;
-       this.hash = SOCK_INODE(sock)->i_ino;
+       struct dentry *dentry;
+       struct qstr name = { .name = "" };
 
-       file->f_dentry = d_alloc(sock_mnt->mnt_sb->s_root, &this);
-       if (unlikely(!file->f_dentry))
+       dentry = d_alloc(sock_mnt->mnt_sb->s_root, &name);
+       if (unlikely(!dentry))
                return -ENOMEM;
 
-       file->f_dentry->d_op = &sockfs_dentry_operations;
-       d_add(file->f_dentry, SOCK_INODE(sock));
-       file->f_vfsmnt = mntget(sock_mnt);
-       file->f_mapping = file->f_dentry->d_inode->i_mapping;
+       dentry->d_op = &sockfs_dentry_operations;
+       /*
+        * We dont want to push this dentry into global dentry hash table.
+        * We pretend dentry is already hashed, by unsetting DCACHE_UNHASHED
+        * This permits a working /proc/$pid/fd/XXX on sockets
+        */
+       dentry->d_flags &= ~DCACHE_UNHASHED;
+       d_instantiate(dentry, SOCK_INODE(sock));
 
        sock->file = file;
-       file->f_op = SOCK_INODE(sock)->i_fop = &socket_file_ops;
-       file->f_mode = FMODE_READ | FMODE_WRITE;
+       init_file(file, sock_mnt, dentry, FMODE_READ | FMODE_WRITE,
+                 &socket_file_ops);
+       SOCK_INODE(sock)->i_fop = &socket_file_ops;
        file->f_flags = O_RDWR;
        file->f_pos = 0;
        file->private_data = sock;
@@ -445,24 +415,11 @@ int sock_map_fd(struct socket *sock)
 
 static struct socket *sock_from_file(struct file *file, int *err)
 {
-       struct inode *inode;
-       struct socket *sock;
-
        if (file->f_op == &socket_file_ops)
                return file->private_data;      /* set in sock_map_fd */
 
-       inode = file->f_dentry->d_inode;
-       if (!S_ISSOCK(inode->i_mode)) {
-               *err = -ENOTSOCK;
-               return NULL;
-       }
-
-       sock = SOCKET_I(inode);
-       if (sock->file != file) {
-               printk(KERN_ERR "socki_lookup: socket file changed!\n");
-               sock->file = file;
-       }
-       return sock;
+       *err = -ENOTSOCK;
+       return NULL;
 }
 
 /**
@@ -636,6 +593,37 @@ int kernel_sendmsg(struct socket *sock, struct msghdr *msg,
        return result;
 }
 
+/*
+ * called from sock_recv_timestamp() if sock_flag(sk, SOCK_RCVTSTAMP)
+ */
+void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
+       struct sk_buff *skb)
+{
+       ktime_t kt = skb->tstamp;
+
+       if (!sock_flag(sk, SOCK_RCVTSTAMPNS)) {
+               struct timeval tv;
+               /* Race occurred between timestamp enabling and packet
+                  receiving.  Fill in the current time for now. */
+               if (kt.tv64 == 0)
+                       kt = ktime_get_real();
+               skb->tstamp = kt;
+               tv = ktime_to_timeval(kt);
+               put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMP, sizeof(tv), &tv);
+       } else {
+               struct timespec ts;
+               /* Race occurred between timestamp enabling and packet
+                  receiving.  Fill in the current time for now. */
+               if (kt.tv64 == 0)
+                       kt = ktime_get_real();
+               skb->tstamp = kt;
+               ts = ktime_to_timespec(kt);
+               put_cmsg(msg, SOL_SOCKET, SCM_TIMESTAMPNS, sizeof(ts), &ts);
+       }
+}
+
+EXPORT_SYMBOL_GPL(__sock_recv_timestamp);
+
 static inline int __sock_recvmsg(struct kiocb *iocb, struct socket *sock,
                                 struct msghdr *msg, size_t size, int flags)
 {
@@ -707,8 +695,19 @@ static ssize_t sock_sendpage(struct file *file, struct page *page,
        return sock->ops->sendpage(sock, page, offset, size, flags);
 }
 
+static ssize_t sock_splice_read(struct file *file, loff_t *ppos,
+                               struct pipe_inode_info *pipe, size_t len,
+                               unsigned int flags)
+{
+       struct socket *sock = file->private_data;
+
+       if (unlikely(!sock->ops->splice_read))
+               return -EINVAL;
+
+       return sock->ops->splice_read(sock, ppos, pipe, len, flags);
+}
+
 static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
-                                        char __user *ubuf, size_t size,
                                         struct sock_iocb *siocb)
 {
        if (!is_sync_kiocb(iocb)) {
@@ -719,16 +718,13 @@ static struct sock_iocb *alloc_sock_iocb(struct kiocb *iocb,
        }
 
        siocb->kiocb = iocb;
-       siocb->async_iov.iov_base = ubuf;
-       siocb->async_iov.iov_len = size;
-
        iocb->private = siocb;
        return siocb;
 }
 
 static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
-                           struct file *file, struct iovec *iov,
-                           unsigned long nr_segs)
+               struct file *file, const struct iovec *iov,
+               unsigned long nr_segs)
 {
        struct socket *sock = file->private_data;
        size_t size = 0;
@@ -748,43 +744,27 @@ static ssize_t do_sock_read(struct msghdr *msg, struct kiocb *iocb,
        return __sock_recvmsg(iocb, sock, msg, size, msg->msg_flags);
 }
 
-static ssize_t sock_readv(struct file *file, const struct iovec *iov,
-                         unsigned long nr_segs, loff_t *ppos)
-{
-       struct kiocb iocb;
-       struct sock_iocb siocb;
-       struct msghdr msg;
-       int ret;
-
-       init_sync_kiocb(&iocb, NULL);
-       iocb.private = &siocb;
-
-       ret = do_sock_read(&msg, &iocb, file, (struct iovec *)iov, nr_segs);
-       if (-EIOCBQUEUED == ret)
-               ret = wait_on_sync_kiocb(&iocb);
-       return ret;
-}
-
-static ssize_t sock_aio_read(struct kiocb *iocb, char __user *ubuf,
-                            size_t count, loff_t pos)
+static ssize_t sock_aio_read(struct kiocb *iocb, const struct iovec *iov,
+                               unsigned long nr_segs, loff_t pos)
 {
        struct sock_iocb siocb, *x;
 
        if (pos != 0)
                return -ESPIPE;
-       if (count == 0)         /* Match SYS5 behaviour */
+
+       if (iocb->ki_left == 0) /* Match SYS5 behaviour */
                return 0;
 
-       x = alloc_sock_iocb(iocb, ubuf, count, &siocb);
+
+       x = alloc_sock_iocb(iocb, &siocb);
        if (!x)
                return -ENOMEM;
-       return do_sock_read(&x->async_msg, iocb, iocb->ki_filp,
-                           &x->async_iov, 1);
+       return do_sock_read(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
 }
 
 static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
-                            struct file *file, struct iovec *iov,
-                            unsigned long nr_segs)
+                       struct file *file, const struct iovec *iov,
+                       unsigned long nr_segs)
 {
        struct socket *sock = file->private_data;
        size_t size = 0;
@@ -806,39 +786,19 @@ static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
        return __sock_sendmsg(iocb, sock, msg, size);
 }
 
-static ssize_t sock_writev(struct file *file, const struct iovec *iov,
-                          unsigned long nr_segs, loff_t *ppos)
-{
-       struct msghdr msg;
-       struct kiocb iocb;
-       struct sock_iocb siocb;
-       int ret;
-
-       init_sync_kiocb(&iocb, NULL);
-       iocb.private = &siocb;
-
-       ret = do_sock_write(&msg, &iocb, file, (struct iovec *)iov, nr_segs);
-       if (-EIOCBQUEUED == ret)
-               ret = wait_on_sync_kiocb(&iocb);
-       return ret;
-}
-
-static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
-                             size_t count, loff_t pos)
+static ssize_t sock_aio_write(struct kiocb *iocb, const struct iovec *iov,
+                         unsigned long nr_segs, loff_t pos)
 {
        struct sock_iocb siocb, *x;
 
        if (pos != 0)
                return -ESPIPE;
-       if (count == 0)         /* Match SYS5 behaviour */
-               return 0;
 
-       x = alloc_sock_iocb(iocb, (void __user *)ubuf, count, &siocb);
+       x = alloc_sock_iocb(iocb, &siocb);
        if (!x)
                return -ENOMEM;
 
-       return do_sock_write(&x->async_msg, iocb, iocb->ki_filp,
-                            &x->async_iov, 1);
+       return do_sock_write(&x->async_msg, iocb, iocb->ki_filp, iov, nr_segs);
 }
 
 /*
@@ -847,9 +807,9 @@ static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
  */
 
 static DEFINE_MUTEX(br_ioctl_mutex);
-static int (*br_ioctl_hook) (unsigned int cmd, void __user *arg) = NULL;
+static int (*br_ioctl_hook) (struct net *, unsigned int cmd, void __user *arg) = NULL;
 
-void brioctl_set(int (*hook) (unsigned int, void __user *))
+void brioctl_set(int (*hook) (struct net *, unsigned int, void __user *))
 {
        mutex_lock(&br_ioctl_mutex);
        br_ioctl_hook = hook;
@@ -859,9 +819,9 @@ void brioctl_set(int (*hook) (unsigned int, void __user *))
 EXPORT_SYMBOL(brioctl_set);
 
 static DEFINE_MUTEX(vlan_ioctl_mutex);
-static int (*vlan_ioctl_hook) (void __user *arg);
+static int (*vlan_ioctl_hook) (struct net *, void __user *arg);
 
-void vlan_ioctl_set(int (*hook) (void __user *))
+void vlan_ioctl_set(int (*hook) (struct net *, void __user *))
 {
        mutex_lock(&vlan_ioctl_mutex);
        vlan_ioctl_hook = hook;
@@ -890,16 +850,20 @@ EXPORT_SYMBOL(dlci_ioctl_set);
 static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 {
        struct socket *sock;
+       struct sock *sk;
        void __user *argp = (void __user *)arg;
        int pid, err;
+       struct net *net;
 
        sock = file->private_data;
+       sk = sock->sk;
+       net = sk->sk_net;
        if (cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
-               err = dev_ioctl(cmd, argp);
+               err = dev_ioctl(net, cmd, argp);
        } else
 #ifdef CONFIG_WIRELESS_EXT
        if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) {
-               err = dev_ioctl(cmd, argp);
+               err = dev_ioctl(net, cmd, argp);
        } else
 #endif                         /* CONFIG_WIRELESS_EXT */
                switch (cmd) {
@@ -912,7 +876,7 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                        break;
                case FIOGETOWN:
                case SIOCGPGRP:
-                       err = put_user(sock->file->f_owner.pid,
+                       err = put_user(f_getown(sock->file),
                                       (int __user *)argp);
                        break;
                case SIOCGIFBR:
@@ -925,7 +889,7 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 
                        mutex_lock(&br_ioctl_mutex);
                        if (br_ioctl_hook)
-                               err = br_ioctl_hook(cmd, argp);
+                               err = br_ioctl_hook(net, cmd, argp);
                        mutex_unlock(&br_ioctl_mutex);
                        break;
                case SIOCGIFVLAN:
@@ -936,14 +900,9 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
 
                        mutex_lock(&vlan_ioctl_mutex);
                        if (vlan_ioctl_hook)
-                               err = vlan_ioctl_hook(argp);
+                               err = vlan_ioctl_hook(net, argp);
                        mutex_unlock(&vlan_ioctl_mutex);
                        break;
-               case SIOCGIFDIVERT:
-               case SIOCSIFDIVERT:
-                       /* Convert this to call through a hook */
-                       err = divert_ioctl(cmd, argp);
-                       break;
                case SIOCADDDLCI:
                case SIOCDELDLCI:
                        err = -ENOPKG;
@@ -964,7 +923,7 @@ static long sock_ioctl(struct file *file, unsigned cmd, unsigned long arg)
                         * to the NIC driver.
                         */
                        if (err == -ENOIOCTLCMD)
-                               err = dev_ioctl(cmd, argp);
+                               err = dev_ioctl(net, cmd, argp);
                        break;
                }
        return err;
@@ -1114,30 +1073,30 @@ int sock_wake_async(struct socket *sock, int how, int band)
        if (!sock || !sock->fasync_list)
                return -1;
        switch (how) {
-       case 1:
-
+       case SOCK_WAKE_WAITD:
                if (test_bit(SOCK_ASYNC_WAITDATA, &sock->flags))
                        break;
                goto call_kill;
-       case 2:
+       case SOCK_WAKE_SPACE:
                if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sock->flags))
                        break;
                /* fall through */
-       case 0:
+       case SOCK_WAKE_IO:
 call_kill:
                __kill_fasync(sock->fasync_list, SIGIO, band);
                break;
-       case 3:
+       case SOCK_WAKE_URG:
                __kill_fasync(sock->fasync_list, SIGURG, band);
        }
        return 0;
 }
 
-static int __sock_create(int family, int type, int protocol,
+static int __sock_create(struct net *net, int family, int type, int protocol,
                         struct socket **res, int kern)
 {
        int err;
        struct socket *sock;
+       const struct net_proto_family *pf;
 
        /*
         *      Check protocol is in range
@@ -1166,6 +1125,21 @@ static int __sock_create(int family, int type, int protocol,
        if (err)
                return err;
 
+       /*
+        *      Allocate the socket and allow the family to set things up. if
+        *      the protocol is 0, the family is instructed to select an appropriate
+        *      default.
+        */
+       sock = sock_alloc();
+       if (!sock) {
+               if (net_ratelimit())
+                       printk(KERN_WARNING "socket: no more sockets\n");
+               return -ENFILE; /* Not exactly a match, but its the
+                                  closest posix thing */
+       }
+
+       sock->type = type;
+
 #if defined(CONFIG_KMOD)
        /* Attempt to load a protocol module if the find failed.
         *
@@ -1173,82 +1147,71 @@ static int __sock_create(int family, int type, int protocol,
         * requested real, full-featured networking support upon configuration.
         * Otherwise module support will break!
         */
-       if (net_families[family] == NULL) {
+       if (net_families[family] == NULL)
                request_module("net-pf-%d", family);
-       }
 #endif
 
-       net_family_read_lock();
-       if (net_families[family] == NULL) {
-               err = -EAFNOSUPPORT;
-               goto out;
-       }
-
-/*
- *     Allocate the socket and allow the family to set things up. if
- *     the protocol is 0, the family is instructed to select an appropriate
- *     default.
- */
-
-       if (!(sock = sock_alloc())) {
-               if (net_ratelimit())
-                       printk(KERN_WARNING "socket: no more sockets\n");
-               err = -ENFILE;  /* Not exactly a match, but its the
-                                  closest posix thing */
-               goto out;
-       }
-
-       sock->type = type;
+       rcu_read_lock();
+       pf = rcu_dereference(net_families[family]);
+       err = -EAFNOSUPPORT;
+       if (!pf)
+               goto out_release;
 
        /*
         * We will call the ->create function, that possibly is in a loadable
         * module, so we have to bump that loadable module refcnt first.
         */
-       err = -EAFNOSUPPORT;
-       if (!try_module_get(net_families[family]->owner))
+       if (!try_module_get(pf->owner))
                goto out_release;
 
-       if ((err = net_families[family]->create(sock, protocol)) < 0) {
-               sock->ops = NULL;
+       /* Now protected by module ref count */
+       rcu_read_unlock();
+
+       err = pf->create(net, sock, protocol);
+       if (err < 0)
                goto out_module_put;
-       }
 
        /*
         * Now to bump the refcnt of the [loadable] module that owns this
         * socket at sock_release time we decrement its refcnt.
         */
-       if (!try_module_get(sock->ops->owner)) {
-               sock->ops = NULL;
-               goto out_module_put;
-       }
+       if (!try_module_get(sock->ops->owner))
+               goto out_module_busy;
+
        /*
         * Now that we're done with the ->create function, the [loadable]
         * module can have its refcnt decremented
         */
-       module_put(net_families[family]->owner);
-       *res = sock;
+       module_put(pf->owner);
        err = security_socket_post_create(sock, family, type, protocol, kern);
        if (err)
-               goto out_release;
+               goto out_sock_release;
+       *res = sock;
 
-out:
-       net_family_read_unlock();
-       return err;
+       return 0;
+
+out_module_busy:
+       err = -EAFNOSUPPORT;
 out_module_put:
-       module_put(net_families[family]->owner);
-out_release:
+       sock->ops = NULL;
+       module_put(pf->owner);
+out_sock_release:
        sock_release(sock);
-       goto out;
+       return err;
+
+out_release:
+       rcu_read_unlock();
+       goto out_sock_release;
 }
 
 int sock_create(int family, int type, int protocol, struct socket **res)
 {
-       return __sock_create(family, type, protocol, res, 0);
+       return __sock_create(current->nsproxy->net_ns, family, type, protocol, res, 0);
 }
 
 int sock_create_kern(int family, int type, int protocol, struct socket **res)
 {
-       return __sock_create(family, type, protocol, res, 1);
+       return __sock_create(&init_net, family, type, protocol, res, 1);
 }
 
 asmlinkage long sys_socket(int family, int type, int protocol)
@@ -1282,6 +1245,7 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
 {
        struct socket *sock1, *sock2;
        int fd1, fd2, err;
+       struct file *newfile1, *newfile2;
 
        /*
         * Obtain the first socket and check if the underlying protocol
@@ -1300,18 +1264,40 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
        if (err < 0)
                goto out_release_both;
 
-       fd1 = fd2 = -1;
+       fd1 = sock_alloc_fd(&newfile1);
+       if (unlikely(fd1 < 0)) {
+               err = fd1;
+               goto out_release_both;
+       }
 
-       err = sock_map_fd(sock1);
-       if (err < 0)
+       fd2 = sock_alloc_fd(&newfile2);
+       if (unlikely(fd2 < 0)) {
+               err = fd2;
+               put_filp(newfile1);
+               put_unused_fd(fd1);
                goto out_release_both;
-       fd1 = err;
+       }
 
-       err = sock_map_fd(sock2);
-       if (err < 0)
-               goto out_close_1;
-       fd2 = err;
+       err = sock_attach_fd(sock1, newfile1);
+       if (unlikely(err < 0)) {
+               goto out_fd2;
+       }
+
+       err = sock_attach_fd(sock2, newfile2);
+       if (unlikely(err < 0)) {
+               fput(newfile1);
+               goto out_fd1;
+       }
+
+       err = audit_fd_pair(fd1, fd2);
+       if (err < 0) {
+               fput(newfile1);
+               fput(newfile2);
+               goto out_fd;
+       }
 
+       fd_install(fd1, newfile1);
+       fd_install(fd2, newfile2);
        /* fd1 and fd2 may be already another descriptors.
         * Not kernel problem.
         */
@@ -1326,17 +1312,23 @@ asmlinkage long sys_socketpair(int family, int type, int protocol,
        sys_close(fd1);
        return err;
 
-out_close_1:
-       sock_release(sock2);
-       sys_close(fd1);
-       return err;
-
 out_release_both:
        sock_release(sock2);
 out_release_1:
        sock_release(sock1);
 out:
        return err;
+
+out_fd2:
+       put_filp(newfile1);
+       sock_release(sock1);
+out_fd1:
+       put_filp(newfile2);
+       sock_release(sock2);
+out_fd:
+       put_unused_fd(fd1);
+       put_unused_fd(fd2);
+       goto out;
 }
 
 /*
@@ -1354,7 +1346,7 @@ asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
        int err, fput_needed;
 
        sock = sockfd_lookup_light(fd, &err, &fput_needed);
-       if(sock) {
+       if (sock) {
                err = move_addr_to_kernel(umyaddr, addrlen, address);
                if (err >= 0) {
                        err = security_socket_bind(sock,
@@ -1376,17 +1368,17 @@ asmlinkage long sys_bind(int fd, struct sockaddr __user *umyaddr, int addrlen)
  *     ready for listening.
  */
 
-int sysctl_somaxconn = SOMAXCONN;
-
 asmlinkage long sys_listen(int fd, int backlog)
 {
        struct socket *sock;
        int err, fput_needed;
+       int somaxconn;
 
        sock = sockfd_lookup_light(fd, &err, &fput_needed);
        if (sock) {
-               if ((unsigned)backlog > sysctl_somaxconn)
-                       backlog = sysctl_somaxconn;
+               somaxconn = sock->sk->sk_net->sysctl_somaxconn;
+               if ((unsigned)backlog > somaxconn)
+                       backlog = somaxconn;
 
                err = security_socket_listen(sock, backlog);
                if (!err)
@@ -1443,7 +1435,7 @@ asmlinkage long sys_accept(int fd, struct sockaddr __user *upeer_sockaddr,
 
        err = sock_attach_fd(newsock, newfile);
        if (err < 0)
-               goto out_fd;
+               goto out_fd_simple;
 
        err = security_socket_accept(sock, newsock);
        if (err)
@@ -1476,6 +1468,11 @@ out_put:
        fput_light(sock->file, fput_needed);
 out:
        return err;
+out_fd_simple:
+       sock_release(newsock);
+       put_filp(newfile);
+       put_unused_fd(newfd);
+       goto out_put;
 out_fd:
        fput(newfile);
        put_unused_fd(newfd);
@@ -1599,15 +1596,11 @@ asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
        struct msghdr msg;
        struct iovec iov;
        int fput_needed;
-       struct file *sock_file;
-
-       sock_file = fget_light(fd, &fput_needed);
-       if (!sock_file)
-               return -EBADF;
 
-       sock = sock_from_file(sock_file, &err);
+       sock = sockfd_lookup_light(fd, &err, &fput_needed);
        if (!sock)
-               goto out_put;
+               goto out;
+
        iov.iov_base = buff;
        iov.iov_len = len;
        msg.msg_name = NULL;
@@ -1629,7 +1622,8 @@ asmlinkage long sys_sendto(int fd, void __user *buff, size_t len,
        err = sock_sendmsg(sock, &msg, len);
 
 out_put:
-       fput_light(sock_file, fput_needed);
+       fput_light(sock->file, fput_needed);
+out:
        return err;
 }
 
@@ -1657,14 +1651,9 @@ asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
        struct msghdr msg;
        char address[MAX_SOCK_ADDR];
        int err, err2;
-       struct file *sock_file;
        int fput_needed;
 
-       sock_file = fget_light(fd, &fput_needed);
-       if (!sock_file)
-               return -EBADF;
-
-       sock = sock_from_file(sock_file, &err);
+       sock = sockfd_lookup_light(fd, &err, &fput_needed);
        if (!sock)
                goto out;
 
@@ -1685,8 +1674,9 @@ asmlinkage long sys_recvfrom(int fd, void __user *ubuf, size_t size,
                if (err2 < 0)
                        err = err2;
        }
+
+       fput_light(sock->file, fput_needed);
 out:
-       fput_light(sock_file, fput_needed);
        return err;
 }
 
@@ -1946,7 +1936,7 @@ asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
         *      kernel msghdr to use the kernel address space)
         */
 
-       uaddr = (void __user *)msg_sys.msg_name;
+       uaddr = (__force void __user *)msg_sys.msg_name;
        uaddr_len = COMPAT_NAMELEN(msg);
        if (MSG_CMSG_COMPAT & flags) {
                err = verify_compat_iovec(&msg_sys, iov, addr, VERIFY_WRITE);
@@ -1957,9 +1947,7 @@ asmlinkage long sys_recvmsg(int fd, struct msghdr __user *msg,
        total_len = err;
 
        cmsg_ptr = (unsigned long)msg_sys.msg_control;
-       msg_sys.msg_flags = 0;
-       if (MSG_CMSG_COMPAT & flags)
-               msg_sys.msg_flags = MSG_CMSG_COMPAT;
+       msg_sys.msg_flags = flags & (MSG_CMSG_CLOEXEC|MSG_CMSG_COMPAT);
 
        if (sock->file->f_flags & O_NONBLOCK)
                flags |= MSG_DONTWAIT;
@@ -2109,13 +2097,16 @@ asmlinkage long sys_socketcall(int call, unsigned long __user *args)
 
 #endif                         /* __ARCH_WANT_SYS_SOCKETCALL */
 
-/*
+/**
+ *     sock_register - add a socket protocol handler
+ *     @ops: description of protocol
+ *
  *     This function is called by a protocol handler that wants to
  *     advertise its address family, and have it linked into the
- *     SOCKET module.
+ *     socket interface. The value ops->family coresponds to the
+ *     socket system call protocol family.
  */
-
-int sock_register(struct net_proto_family *ops)
+int sock_register(const struct net_proto_family *ops)
 {
        int err;
 
@@ -2124,33 +2115,44 @@ int sock_register(struct net_proto_family *ops)
                       NPROTO);
                return -ENOBUFS;
        }
-       net_family_write_lock();
-       err = -EEXIST;
-       if (net_families[ops->family] == NULL) {
+
+       spin_lock(&net_family_lock);
+       if (net_families[ops->family])
+               err = -EEXIST;
+       else {
                net_families[ops->family] = ops;
                err = 0;
        }
-       net_family_write_unlock();
+       spin_unlock(&net_family_lock);
+
        printk(KERN_INFO "NET: Registered protocol family %d\n", ops->family);
        return err;
 }
 
-/*
+/**
+ *     sock_unregister - remove a protocol handler
+ *     @family: protocol family to remove
+ *
  *     This function is called by a protocol handler that wants to
  *     remove its address family, and have it unlinked from the
- *     SOCKET module.
+ *     new socket creation.
+ *
+ *     If protocol handler is a module, then it can use module reference
+ *     counts to protect against new references. If protocol handler is not
+ *     a module then it needs to provide its own protection in
+ *     the ops->create routine.
  */
-
-int sock_unregister(int family)
+void sock_unregister(int family)
 {
-       if (family < 0 || family >= NPROTO)
-               return -1;
+       BUG_ON(family < 0 || family >= NPROTO);
 
-       net_family_write_lock();
+       spin_lock(&net_family_lock);
        net_families[family] = NULL;
-       net_family_write_unlock();
+       spin_unlock(&net_family_lock);
+
+       synchronize_rcu();
+
        printk(KERN_INFO "NET: Unregistered protocol family %d\n", family);
-       return 0;
 }
 
 static int __init sock_init(void)
@@ -2240,6 +2242,7 @@ int kernel_accept(struct socket *sock, struct socket **newsock, int flags)
        err = sock->ops->accept(sock, *newsock, flags);
        if (err < 0) {
                sock_release(*newsock);
+               *newsock = NULL;
                goto done;
        }
 
@@ -2250,7 +2253,7 @@ done:
 }
 
 int kernel_connect(struct socket *sock, struct sockaddr *addr, int addrlen,
-                   int flags)
+                  int flags)
 {
        return sock->ops->connect(sock, addr, addrlen, flags);
 }
@@ -2320,6 +2323,11 @@ int kernel_sock_ioctl(struct socket *sock, int cmd, unsigned long arg)
        return err;
 }
 
+int kernel_sock_shutdown(struct socket *sock, enum sock_shutdown_cmd how)
+{
+       return sock->ops->shutdown(sock, how);
+}
+
 /* ABI emulation layers need these two */
 EXPORT_SYMBOL(move_addr_to_kernel);
 EXPORT_SYMBOL(move_addr_to_user);
@@ -2346,3 +2354,4 @@ EXPORT_SYMBOL(kernel_getsockopt);
 EXPORT_SYMBOL(kernel_setsockopt);
 EXPORT_SYMBOL(kernel_sendpage);
 EXPORT_SYMBOL(kernel_sock_ioctl);
+EXPORT_SYMBOL(kernel_sock_shutdown);