vmci: simplify qp_dequeue_locked()

* no need for callback argument - it's always the same one
* fold __qp_memcpy_from_queue() into its only caller, get rid of dead code
* pass struct iov_iter * without casting to void *
* don't pass buf_size at all - it's always iov_iter_count(to)

Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/drivers/misc/vmw_vmci/vmci_queue_pair.c b/drivers/misc/vmw_vmci/vmci_queue_pair.c
index a0c10f8..09314b9 100644 (file)
--- a/drivers/misc/vmw_vmci/vmci_queue_pair.c
+++ b/drivers/misc/vmw_vmci/vmci_queue_pair.c
@@ -142,9 +142,6 @@
 typedef int vmci_memcpy_to_queue_func(struct vmci_queue *queue,
                                      u64 queue_offset, const void *src,
                                      size_t src_offset, size_t size);
-typedef int vmci_memcpy_from_queue_func(void *dest, size_t dest_offset,
-                                       const struct vmci_queue *queue,
-                                       u64 queue_offset, size_t size);
 
 /* The Kernel specific component of the struct vmci_queue structure. */
 struct vmci_queue_kern_if {
@@ -411,11 +408,9 @@ static int __qp_memcpy_to_queue(struct vmci_queue *queue,
  * by traversing the offset -> page translation structure for the queue.
  * Assumes that offset + size does not wrap around in the queue.
  */
-static int __qp_memcpy_from_queue(void *dest,
-                                 const struct vmci_queue *queue,
-                                 u64 queue_offset,
-                                 size_t size,
-                                 bool is_iovec)
+static int qp_memcpy_from_queue_iter(struct iov_iter *to,
+                                   const struct vmci_queue *queue,
+                                   u64 queue_offset, size_t size)
 {
        struct vmci_queue_kern_if *kernel_if = queue->kernel_if;
        size_t bytes_copied = 0;
@@ -427,6 +422,7 @@ static int __qp_memcpy_from_queue(void *dest,
                    (queue_offset + bytes_copied) & (PAGE_SIZE - 1);
                void *va;
                size_t to_copy;
+               int err;
 
                if (kernel_if->host)
                        va = kmap(kernel_if->u.h.page[page_index]);
@@ -440,21 +436,12 @@ static int __qp_memcpy_from_queue(void *dest,
                else
                        to_copy = size - bytes_copied;
 
-               if (is_iovec) {
-                       struct iov_iter *to = dest;
-                       int err;
-
-                       err = copy_to_iter((u8 *)va + page_offset, to_copy, to);
-                       if (err != to_copy) {
-                               if (kernel_if->host)
-                                       kunmap(kernel_if->u.h.page[page_index]);
-                               return VMCI_ERROR_INVALID_ARGS;
-                       }
-               } else {
-                       memcpy((u8 *)dest + bytes_copied,
-                              (u8 *)va + page_offset, to_copy);
+               err = copy_to_iter((u8 *)va + page_offset, to_copy, to);
+               if (err != to_copy) {
+                       if (kernel_if->host)
+                               kunmap(kernel_if->u.h.page[page_index]);
+                       return VMCI_ERROR_INVALID_ARGS;
                }
-
                bytes_copied += to_copy;
                if (kernel_if->host)
                        kunmap(kernel_if->u.h.page[page_index]);
@@ -592,21 +579,6 @@ static int qp_memcpy_to_queue_iov(struct vmci_queue *queue,
 }
 
 /*
- * Copies to a given iovec from a VMCI Queue.
- */
-static int qp_memcpy_from_queue_iov(void *dest,
-                                   size_t dest_offset,
-                                   const struct vmci_queue *queue,
-                                   u64 queue_offset, size_t size)
-{
-       /*
-        * We ignore dest_offset because dest is really a struct iovec * and
-        * will maintain offset internally.
-        */
-       return __qp_memcpy_from_queue(dest, queue, queue_offset, size, true);
-}
-
-/*
  * Allocates kernel VA space of specified size plus space for the queue
  * and kernel interface.  This is different from the guest queue allocator,
  * because we do not allocate our own queue header/data pages here but
@@ -2679,11 +2651,10 @@ static ssize_t qp_enqueue_locked(struct vmci_queue *produce_q,
 static ssize_t qp_dequeue_locked(struct vmci_queue *produce_q,
                                 struct vmci_queue *consume_q,
                                 const u64 consume_q_size,
-                                void *buf,
-                                size_t buf_size,
-                                vmci_memcpy_from_queue_func memcpy_from_queue,
+                                struct iov_iter *to,
                                 bool update_consumer)
 {
+       size_t buf_size = iov_iter_count(to);
        s64 buf_ready;
        u64 head;
        size_t read;
@@ -2705,15 +2676,15 @@ static ssize_t qp_dequeue_locked(struct vmci_queue *produce_q,
        read = (size_t) (buf_ready > buf_size ? buf_size : buf_ready);
        head = vmci_q_header_consumer_head(produce_q->q_header);
        if (likely(head + read < consume_q_size)) {
-               result = memcpy_from_queue(buf, 0, consume_q, head, read);
+               result = qp_memcpy_from_queue_iter(to, consume_q, head, read);
        } else {
                /* Head pointer wraps around. */
 
                const size_t tmp = (size_t) (consume_q_size - head);
 
-               result = memcpy_from_queue(buf, 0, consume_q, head, tmp);
+               result = qp_memcpy_from_queue_iter(to, consume_q, head, tmp);
                if (result >= VMCI_SUCCESS)
-                       result = memcpy_from_queue(buf, tmp, consume_q, 0,
+                       result = qp_memcpy_from_queue_iter(to, consume_q, 0,
                                                   read - tmp);
 
        }
@@ -3162,8 +3133,7 @@ ssize_t vmci_qpair_dequeue(struct vmci_qp *qpair,
                result = qp_dequeue_locked(qpair->produce_q,
                                           qpair->consume_q,
                                           qpair->consume_q_size,
-                                          &to, buf_size,
-                                          qp_memcpy_from_queue_iov, true);
+                                          &to, true);
 
                if (result == VMCI_ERROR_QUEUEPAIR_NOT_READY &&
                    !qp_wait_for_ready_queue(qpair))
@@ -3208,8 +3178,7 @@ ssize_t vmci_qpair_peek(struct vmci_qp *qpair,
                result = qp_dequeue_locked(qpair->produce_q,
                                           qpair->consume_q,
                                           qpair->consume_q_size,
-                                          &to, buf_size,
-                                          qp_memcpy_from_queue_iov, false);
+                                          &to, false);
 
                if (result == VMCI_ERROR_QUEUEPAIR_NOT_READY &&
                    !qp_wait_for_ready_queue(qpair))
@@ -3292,9 +3261,7 @@ ssize_t vmci_qpair_dequev(struct vmci_qp *qpair,
                result = qp_dequeue_locked(qpair->produce_q,
                                           qpair->consume_q,
                                           qpair->consume_q_size,
-                                          &msg->msg_iter, msg_data_left(msg),
-                                          qp_memcpy_from_queue_iov,
-                                          true);
+                                          &msg->msg_iter, true);
 
                if (result == VMCI_ERROR_QUEUEPAIR_NOT_READY &&
                    !qp_wait_for_ready_queue(qpair))
@@ -3336,9 +3303,7 @@ ssize_t vmci_qpair_peekv(struct vmci_qp *qpair,
                result = qp_dequeue_locked(qpair->produce_q,
                                           qpair->consume_q,
                                           qpair->consume_q_size,
-                                          &msg->msg_iter, msg_data_left(msg),
-                                          qp_memcpy_from_queue_iov,
-                                          false);
+                                          &msg->msg_iter, false);
 
                if (result == VMCI_ERROR_QUEUEPAIR_NOT_READY &&
                    !qp_wait_for_ready_queue(qpair))