[NET]: restructure sock_aio_{read,write} / sock_{readv,writev}

Mid-term I plan to restructure the file_operations so that we don't need
to have all these duplicate aio and vectored versions.  This patch is
a small step in that direction but also a worthwile cleanup on it's own:

(1) introduce a alloc_sock_iocb helper that encapsulates allocating a
    proper sock_iocb
(2) add do_sock_read and do_sock_write helpers for common read/write
    code

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: David S. Miller <davem@davemloft.net>

diff --git a/net/socket.c b/net/socket.c
index f40957adc7c70886cb4ee598d56096d482b77c19..0dde6dade2b17b60afac9ffc937f724f3ba9f6b3 100644 (file)
--- a/net/socket.c
+++ b/net/socket.c
@@ -640,154 +640,150 @@ static void sock_aio_dtor(struct kiocb *iocb)
        kfree(iocb->private);
 }
 
-/*
- *     Read data from a socket. ubuf is a user mode pointer. We make sure the user
- *     area ubuf...ubuf+size-1 is writable before asking the protocol.
- */
-
-static ssize_t sock_aio_read(struct kiocb *iocb, char __user *ubuf,
-                        size_t size, loff_t pos)
+static ssize_t sock_sendpage(struct file *file, struct page *page,
+                            int offset, size_t size, loff_t *ppos, int more)
 {
-       struct sock_iocb *x, siocb;
        struct socket *sock;
        int flags;
 
-       if (pos != 0)
-               return -ESPIPE;
-       if (size==0)            /* Match SYS5 behaviour */
-               return 0;
+       sock = file->private_data;
 
-       if (is_sync_kiocb(iocb))
-               x = &siocb;
-       else {
-               x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL);
-               if (!x)
-                       return -ENOMEM;
+       flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
+       if (more)
+               flags |= MSG_MORE;
+
+       return sock->ops->sendpage(sock, page, offset, size, 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)) {
+               siocb = kmalloc(sizeof(*siocb), GFP_KERNEL);
+               if (!siocb)
+                       return NULL;
                iocb->ki_dtor = sock_aio_dtor;
        }
-       iocb->private = x;
-       x->kiocb = iocb;
-       sock = iocb->ki_filp->private_data; 
 
-       x->async_msg.msg_name = NULL;
-       x->async_msg.msg_namelen = 0;
-       x->async_msg.msg_iov = &x->async_iov;
-       x->async_msg.msg_iovlen = 1;
-       x->async_msg.msg_control = NULL;
-       x->async_msg.msg_controllen = 0;
-       x->async_iov.iov_base = ubuf;
-       x->async_iov.iov_len = size;
-       flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
+       siocb->kiocb = iocb;
+       siocb->async_iov.iov_base = ubuf;
+       siocb->async_iov.iov_len = size;
 
-       return __sock_recvmsg(iocb, sock, &x->async_msg, size, flags);
+       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 socket *sock = file->private_data;
+       size_t size = 0;
+       int i;
 
-/*
- *     Write data to a socket. We verify that the user area ubuf..ubuf+size-1
- *     is readable by the user process.
- */
+        for (i = 0 ; i < nr_segs ; i++)
+                size += iov[i].iov_len;
 
-static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
-                         size_t size, loff_t pos)
+       msg->msg_name = NULL;
+       msg->msg_namelen = 0;
+       msg->msg_control = NULL;
+       msg->msg_controllen = 0;
+       msg->msg_iov = (struct iovec *) iov;
+       msg->msg_iovlen = nr_segs;
+       msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
+
+       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 sock_iocb *x, siocb;
-       struct socket *sock;
-       
+       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)
+{
+       struct sock_iocb siocb, *x;
+
        if (pos != 0)
                return -ESPIPE;
-       if(size==0)             /* Match SYS5 behaviour */
+       if (count == 0)         /* Match SYS5 behaviour */
                return 0;
 
-       if (is_sync_kiocb(iocb))
-               x = &siocb;
-       else {
-               x = kmalloc(sizeof(struct sock_iocb), GFP_KERNEL);
-               if (!x)
-                       return -ENOMEM;
-               iocb->ki_dtor = sock_aio_dtor;
-       }
-       iocb->private = x;
-       x->kiocb = iocb;
-       sock = iocb->ki_filp->private_data; 
-
-       x->async_msg.msg_name = NULL;
-       x->async_msg.msg_namelen = 0;
-       x->async_msg.msg_iov = &x->async_iov;
-       x->async_msg.msg_iovlen = 1;
-       x->async_msg.msg_control = NULL;
-       x->async_msg.msg_controllen = 0;
-       x->async_msg.msg_flags = !(iocb->ki_filp->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
-       if (sock->type == SOCK_SEQPACKET)
-               x->async_msg.msg_flags |= MSG_EOR;
-       x->async_iov.iov_base = (void __user *)ubuf;
-       x->async_iov.iov_len = size;
-       
-       return __sock_sendmsg(iocb, sock, &x->async_msg, size);
+       x = alloc_sock_iocb(iocb, ubuf, count, &siocb);
+       if (!x)
+               return -ENOMEM;
+       return do_sock_read(&x->async_msg, iocb, iocb->ki_filp,
+                       &x->async_iov, 1);
 }
 
-static ssize_t sock_sendpage(struct file *file, struct page *page,
-                            int offset, size_t size, loff_t *ppos, int more)
+static ssize_t do_sock_write(struct msghdr *msg, struct kiocb *iocb,
+               struct file *file, struct iovec *iov, unsigned long nr_segs)
 {
-       struct socket *sock;
-       int flags;
+       struct socket *sock = file->private_data;
+       size_t size = 0;
+       int i;
 
-       sock = file->private_data;
+        for (i = 0 ; i < nr_segs ; i++)
+                size += iov[i].iov_len;
 
-       flags = !(file->f_flags & O_NONBLOCK) ? 0 : MSG_DONTWAIT;
-       if (more)
-               flags |= MSG_MORE;
+       msg->msg_name = NULL;
+       msg->msg_namelen = 0;
+       msg->msg_control = NULL;
+       msg->msg_controllen = 0;
+       msg->msg_iov = (struct iovec *) iov;
+       msg->msg_iovlen = nr_segs;
+       msg->msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
+       if (sock->type == SOCK_SEQPACKET)
+               msg->msg_flags |= MSG_EOR;
 
-       return sock->ops->sendpage(sock, page, offset, size, flags);
+       return __sock_sendmsg(iocb, sock, msg, size);
 }
 
-static int sock_readv_writev(int type,
-                            struct file * file, const struct iovec * iov,
-                            long count, size_t size)
+static ssize_t sock_writev(struct file *file, const struct iovec *iov,
+                          unsigned long nr_segs, loff_t *ppos)
 {
        struct msghdr msg;
-       struct socket *sock;
+       struct kiocb iocb;
+       struct sock_iocb siocb;
+       int ret;
 
-       sock = file->private_data;
+       init_sync_kiocb(&iocb, NULL);
+       iocb.private = &siocb;
 
-       msg.msg_name = NULL;
-       msg.msg_namelen = 0;
-       msg.msg_control = NULL;
-       msg.msg_controllen = 0;
-       msg.msg_iov = (struct iovec *) iov;
-       msg.msg_iovlen = count;
-       msg.msg_flags = (file->f_flags & O_NONBLOCK) ? MSG_DONTWAIT : 0;
+       ret = do_sock_write(&msg, &iocb, file, (struct iovec *)iov, nr_segs);
+       if (-EIOCBQUEUED == ret)
+               ret = wait_on_sync_kiocb(&iocb);
+       return ret;
+}
 
-       /* read() does a VERIFY_WRITE */
-       if (type == VERIFY_WRITE)
-               return sock_recvmsg(sock, &msg, size, msg.msg_flags);
+static ssize_t sock_aio_write(struct kiocb *iocb, const char __user *ubuf,
+                         size_t count, loff_t pos)
+{
+       struct sock_iocb siocb, *x;
 
-       if (sock->type == SOCK_SEQPACKET)
-               msg.msg_flags |= MSG_EOR;
+       if (pos != 0)
+               return -ESPIPE;
+       if (count == 0)         /* Match SYS5 behaviour */
+               return 0;
 
-       return sock_sendmsg(sock, &msg, size);
-}
+       x = alloc_sock_iocb(iocb, (void __user *)ubuf, count, &siocb);
+       if (!x)
+               return -ENOMEM;
 
-static ssize_t sock_readv(struct file *file, const struct iovec *vector,
-                         unsigned long count, loff_t *ppos)
-{
-       size_t tot_len = 0;
-       int i;
-        for (i = 0 ; i < count ; i++)
-                tot_len += vector[i].iov_len;
-       return sock_readv_writev(VERIFY_WRITE,
-                                file, vector, count, tot_len);
-}
-       
-static ssize_t sock_writev(struct file *file, const struct iovec *vector,
-                          unsigned long count, loff_t *ppos)
-{
-       size_t tot_len = 0;
-       int i;
-        for (i = 0 ; i < count ; i++)
-                tot_len += vector[i].iov_len;
-       return sock_readv_writev(VERIFY_READ,
-                                file, vector, count, tot_len);
+       return do_sock_write(&x->async_msg, iocb, iocb->ki_filp,
+                       &x->async_iov, 1);
 }