binder: add functions to copy to/from binder buffers

Avoid vm_area when copying to or from binder buffers.
Instead, new copy functions are added that copy from
kernel space to binder buffer space. These use
kmap_atomic() and kunmap_atomic() to create temporary
mappings and then memcpy() is used to copy within
that page.

Also, kmap_atomic() / kunmap_atomic() use the appropriate
cache flushing to support VIVT cache architectures.
Allow binder to build if CPU_CACHE_VIVT is defined.

Several uses of the new functions are added here. More
to follow in subsequent patches.

Signed-off-by: Todd Kjos <tkjos@google.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 59 insertions, 0 deletions

diff --git a/drivers/android/binder_alloc.c b/drivers/android/binder_alloc.c
index 94c0d85c4e75..2eebff4be83e 100644
--- a/drivers/android/binder_alloc.c
+++ b/drivers/android/binder_alloc.c
@@ -1166,3 +1166,62 @@ binder_alloc_copy_user_to_buffer(struct binder_alloc *alloc,
         }
         return 0;
 }
+
+static void binder_alloc_do_buffer_copy(struct binder_alloc *alloc,
+                                        bool to_buffer,
+                                        struct binder_buffer *buffer,
+                                        binder_size_t buffer_offset,
+                                        void *ptr,
+                                        size_t bytes)
+{
+        /* All copies must be 32-bit aligned and 32-bit size */
+        BUG_ON(!check_buffer(alloc, buffer, buffer_offset, bytes));
+
+        while (bytes) {
+                unsigned long size;
+                struct page *page;
+                pgoff_t pgoff;
+                void *tmpptr;
+                void *base_ptr;
+
+                page = binder_alloc_get_page(alloc, buffer,
+                                             buffer_offset, &pgoff);
+                size = min_t(size_t, bytes, PAGE_SIZE - pgoff);
+                base_ptr = kmap_atomic(page);
+                tmpptr = base_ptr + pgoff;
+                if (to_buffer)
+                        memcpy(tmpptr, ptr, size);
+                else
+                        memcpy(ptr, tmpptr, size);
+                /*
+                 * kunmap_atomic() takes care of flushing the cache
+                 * if this device has VIVT cache arch
+                 */
+                kunmap_atomic(base_ptr);
+                bytes -= size;
+                pgoff = 0;
+                ptr = ptr + size;
+                buffer_offset += size;
+        }
+}
+
+void binder_alloc_copy_to_buffer(struct binder_alloc *alloc,
+                                 struct binder_buffer *buffer,
+                                 binder_size_t buffer_offset,
+                                 void *src,
+                                 size_t bytes)
+{
+        binder_alloc_do_buffer_copy(alloc, true, buffer, buffer_offset,
+                                    src, bytes);
+}
+
+void binder_alloc_copy_from_buffer(struct binder_alloc *alloc,
+                                   void *dest,
+                                   struct binder_buffer *buffer,
+                                   binder_size_t buffer_offset,
+                                   size_t bytes)
+{
+        binder_alloc_do_buffer_copy(alloc, false, buffer, buffer_offset,
+                                    dest, bytes);
+}
+