[fifo] Make FifoDispatcher operations take user_ptr

Change-Id: I0a6d87b5945a7d09ec61191b9310b74382a31a5a
diff --git a/kernel/object/fifo_dispatcher.cpp b/kernel/object/fifo_dispatcher.cpp
index 90e8e67..b225e21 100644
--- a/kernel/object/fifo_dispatcher.cpp
+++ b/kernel/object/fifo_dispatcher.cpp
@@ -8,7 +8,6 @@
 
 #include <string.h>
 
-#include <lib/user_copy/user_ptr.h>
 #include <zircon/rights.h>
 #include <fbl/alloc_checker.h>
 #include <fbl/auto_lock.h>
@@ -121,7 +120,7 @@
     state_tracker_.UpdateState(ZX_FIFO_WRITABLE, ZX_FIFO_PEER_CLOSED);
 }
 
-zx_status_t FifoDispatcher::WriteFromUser(const uint8_t* ptr, size_t len, uint32_t* actual) {
+zx_status_t FifoDispatcher::WriteFromUser(user_ptr<const uint8_t> ptr, size_t len, uint32_t* actual) {
     canary_.Assert();
 
     fbl::RefPtr<FifoDispatcher> other;
@@ -135,7 +134,7 @@
     return other->WriteSelf(ptr, len, actual);
 }
 
-zx_status_t FifoDispatcher::WriteSelf(const uint8_t* ptr, size_t bytelen, uint32_t* actual) {
+zx_status_t FifoDispatcher::WriteSelf(user_ptr<const uint8_t> ptr, size_t bytelen, uint32_t* actual) {
     canary_.Assert();
 
     size_t count = bytelen / elem_size_;
@@ -166,8 +165,8 @@
         // number of slots we can actually copy
         size_t to_copy = (count > n) ? n : count;
 
-        zx_status_t status = make_user_ptr(ptr).copy_array_from_user(&data_[offset * elem_size_],
-                                                                     to_copy * elem_size_);
+        zx_status_t status = ptr.copy_array_from_user(&data_[offset * elem_size_],
+                                                      to_copy * elem_size_);
         if (status != ZX_OK) {
             // roll back, in case this is the second copy
             head_ = old_head;
@@ -178,7 +177,7 @@
         // due to size limitations on fifo, to_copy will always fit in a u32
         head_ += static_cast<uint32_t>(to_copy);
         count -= to_copy;
-        ptr += to_copy * elem_size_;
+        ptr = ptr.byte_offset(to_copy * elem_size_);
     }
 
     // if was empty, we've become readable
@@ -193,7 +192,7 @@
     return ZX_OK;
 }
 
-zx_status_t FifoDispatcher::ReadToUser(uint8_t* ptr, size_t bytelen, uint32_t* actual) {
+zx_status_t FifoDispatcher::ReadToUser(user_ptr<uint8_t> ptr, size_t bytelen, uint32_t* actual) {
     canary_.Assert();
 
     size_t count = bytelen / elem_size_;
@@ -224,8 +223,8 @@
         // number of slots we can actually copy
         size_t to_copy = (count > n) ? n : count;
 
-        zx_status_t status = make_user_ptr(ptr).copy_array_to_user(&data_[offset * elem_size_],
-                                                                   to_copy * elem_size_);
+        zx_status_t status = ptr.copy_array_to_user(&data_[offset * elem_size_],
+                                                    to_copy * elem_size_);
         if (status != ZX_OK) {
             // roll back, in case this is the second copy
             tail_ = old_tail;
@@ -236,8 +235,7 @@
         // due to size limitations on fifo, to_copy will always fit in a u32
         tail_ += static_cast<uint32_t>(to_copy);
         count -= to_copy;
-        ptr += to_copy * elem_size_;
-
+        ptr = ptr.byte_offset(to_copy * elem_size_);
     }
 
     // if we were full, we have become writable
diff --git a/kernel/object/include/object/fifo_dispatcher.h b/kernel/object/include/object/fifo_dispatcher.h
index e12f165..5c617c1 100644
--- a/kernel/object/include/object/fifo_dispatcher.h
+++ b/kernel/object/include/object/fifo_dispatcher.h
@@ -15,6 +15,7 @@
 #include <fbl/canary.h>
 #include <fbl/mutex.h>
 #include <fbl/ref_counted.h>
+#include <lib/user_copy/user_ptr.h>
 
 class FifoDispatcher final : public Dispatcher {
 public:
@@ -31,14 +32,14 @@
     void on_zero_handles() final;
     zx_status_t user_signal(uint32_t clear_mask, uint32_t set_mask, bool peer) final;
 
-    zx_status_t WriteFromUser(const uint8_t* src, size_t len, uint32_t* actual);
-    zx_status_t ReadToUser(uint8_t* dst, size_t len, uint32_t* actual);
+    zx_status_t WriteFromUser(user_ptr<const uint8_t> src, size_t len, uint32_t* actual);
+    zx_status_t ReadToUser(user_ptr<uint8_t> dst, size_t len, uint32_t* actual);
 
 private:
     FifoDispatcher(uint32_t options, uint32_t elem_count, uint32_t elem_size,
                    fbl::unique_ptr<uint8_t[]> data);
     void Init(fbl::RefPtr<FifoDispatcher> other);
-    zx_status_t WriteSelf(const uint8_t* ptr, size_t len, uint32_t* actual);
+    zx_status_t WriteSelf(user_ptr<const uint8_t> ptr, size_t len, uint32_t* actual);
     zx_status_t UserSignalSelf(uint32_t clear_mask, uint32_t set_mask);
 
     void OnPeerZeroHandles();
diff --git a/kernel/syscalls/syscalls_fifo.cpp b/kernel/syscalls/syscalls_fifo.cpp
index 0aca1d3..bc332c4 100644
--- a/kernel/syscalls/syscalls_fifo.cpp
+++ b/kernel/syscalls/syscalls_fifo.cpp
@@ -67,8 +67,7 @@
         return status;
 
     uint32_t actual;
-    // TODO(andymutton): Change FifoDispatcher to accept user_ptr
-    status = fifo->WriteFromUser(reinterpret_cast<const uint8_t*>(entries.get()), len, &actual);
+    status = fifo->WriteFromUser(entries.reinterpret<const uint8_t>(), len, &actual);
     if (status != ZX_OK)
         return status;
 
@@ -87,8 +86,7 @@
         return status;
 
     uint32_t actual;
-    // TODO(andymutton): Change FifoDispatcher to accept user_ptr
-    status = fifo->ReadToUser(reinterpret_cast<uint8_t*>(entries.get()), len, &actual);
+    status = fifo->ReadToUser(entries.reinterpret<uint8_t>(), len, &actual);
     if (status != ZX_OK)
         return status;