diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 9db279f..cfd2f30 100644
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -165,10 +165,9 @@
 	"syscall/zx/fidl/bindingstest": {"L0"},
 	"syscall/zx/io":                {"L0"},
 	"syscall/zx/mem":               {"L0"},
-	"syscall/zx/mxerror":           {"L0", "fmt"},
 	"syscall/zx/mxnet":             {"L0"},
 	"syscall/zx/net":               {"L0"},
-	"syscall/zx/zxsocket":          {"L0", "syscall", "syscall/zx/mxerror"},
+	"syscall/zx/zxsocket":          {"L0", "syscall"},
 	"syscall/zx/zxwait":            {"L0"},
 
 	"internal/syscall/unix":             {"L0", "syscall"},
diff --git a/src/internal/poll/fd_fuchsia.go b/src/internal/poll/fd_fuchsia.go
index 152e6ca..89b703d 100644
--- a/src/internal/poll/fd_fuchsia.go
+++ b/src/internal/poll/fd_fuchsia.go
@@ -214,18 +214,16 @@
 		code, err := s.Accept(0)
 		if code == syscall.EAGAIN {
 			// TODO: non-blocking support, pass this to the poller
-			obs, err := s.Wait(mxnet.MXSIO_SIGNAL_INCOMING|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
-			if err != nil {
+			if obs, err := s.Wait(mxnet.MXSIO_SIGNAL_INCOMING|zx.SignalSocketPeerClosed, zx.TimensecInfinite); err != nil {
 				return nil, err
-			}
-			if obs&zx.SignalSocketPeerClosed != 0 {
+			} else if obs&zx.SignalSocketPeerClosed != 0 {
 				return nil, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket"}
-			}
-			if obs&mxnet.MXSIO_SIGNAL_INCOMING != 0 {
-				code, err = s.Accept(0)
+			} else if obs&mxnet.MXSIO_SIGNAL_INCOMING != 0 {
+				// fallthrough
 			} else {
 				panic("unreachable")
 			}
+			code, err = s.Accept(0)
 		}
 		if err != nil {
 			return nil, err
diff --git a/src/net/ipsock_fuchsia.go b/src/net/ipsock_fuchsia.go
index e2503af..53b06ac 100644
--- a/src/net/ipsock_fuchsia.go
+++ b/src/net/ipsock_fuchsia.go
@@ -69,10 +69,8 @@
 	socketProvider.mu.Lock()
 	defer socketProvider.mu.Unlock()
 	if socketProvider.h == zx.HandleInvalid {
-		c0, c1, err := zx.NewChannel(0)
-		if err == nil {
-			err = fdio.ServiceConnect("/svc/"+zxnet.SocketProviderName, zx.Handle(c0))
-			if err == nil {
+		if c0, c1, err := zx.NewChannel(0); err == nil {
+			if err := fdio.ServiceConnect("/svc/"+zxnet.SocketProviderName, zx.Handle(c0)); err == nil {
 				socketProvider.h = zx.Handle(c1)
 			}
 		}
@@ -157,19 +155,17 @@
 		b = b[:addrlen]
 		code, err := fd.sock.Connect(b)
 		if code == syscall.EINPROGRESS {
-			obs, err := fd.sock.Wait(mxnet.MXSIO_SIGNAL_OUTGOING|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
-			if err != nil {
+			if obs, err := fd.sock.Wait(mxnet.MXSIO_SIGNAL_OUTGOING|zx.SignalSocketPeerClosed, zx.TimensecInfinite); err != nil {
 				return nil, err
-			}
-			if obs&zx.SignalSocketPeerClosed != 0 {
+			} else if obs&zx.SignalSocketPeerClosed != 0 {
 				return nil, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket"}
-			}
-			if obs&mxnet.MXSIO_SIGNAL_OUTGOING != 0 {
-				// Call connect again to learn the result.
-				code, err = fd.sock.Connect(b)
+			} else if obs&mxnet.MXSIO_SIGNAL_OUTGOING != 0 {
+				// fallthrough
 			} else {
 				panic("unreachable")
 			}
+			// Call connect again to learn the result.
+			code, err = fd.sock.Connect(b)
 		}
 		if err != nil {
 			return nil, err
diff --git a/src/os/error_fuchsia.go b/src/os/error_fuchsia.go
index 0b89e7c..e3a655a 100644
--- a/src/os/error_fuchsia.go
+++ b/src/os/error_fuchsia.go
@@ -13,8 +13,7 @@
 
 func isExist(err error) bool {
 	err = underlyingError(err)
-	switch err := err.(type) {
-	case *zx.Error:
+	if err, ok := err.(*zx.Error); ok {
 		return err.Status == zx.ErrAlreadyExists
 	}
 	return err == syscall.EEXIST || err == syscall.ENOTEMPTY || err == ErrExist
@@ -22,8 +21,7 @@
 
 func isNotExist(err error) bool {
 	err = underlyingError(err)
-	switch err := err.(type) {
-	case *zx.Error:
+	if err, ok := err.(*zx.Error); ok {
 		return err.Status == zx.ErrNotFound
 	}
 	return err == syscall.ENOENT || err == ErrNotExist
@@ -31,8 +29,7 @@
 
 func isPermission(err error) bool {
 	err = underlyingError(err)
-	switch err := err.(type) {
-	case *zx.Error:
+	if err, ok := err.(*zx.Error); ok {
 		return err.Status == zx.ErrAccessDenied
 	}
 	return err == syscall.EACCES || err == syscall.EPERM || err == ErrPermission
diff --git a/src/syscall/syscall_fuchsia.go b/src/syscall/syscall_fuchsia.go
index b087473..c473b5f 100644
--- a/src/syscall/syscall_fuchsia.go
+++ b/src/syscall/syscall_fuchsia.go
@@ -440,18 +440,14 @@
 	return 0, EINVAL
 }
 
-func Seek(fd int, offset int64, whence int) (off int64, err error) {
+func Seek(fd int, offset int64, whence int) (int64, error) {
 	fdsMu.Lock()
 	f := fds[fd-fdsOff]
 	fdsMu.Unlock()
-	off, err = f.Seek(offset, whence)
-	if err != nil {
-		if status, isStatus := err.(*zx.Error); isStatus {
-			if status.Status == zx.ErrNotSupported {
-				if _, isPipe := f.(*fdio.Pipe); isPipe {
-					return off, ESPIPE
-				}
-			}
+	off, err := f.Seek(offset, whence)
+	if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrNotSupported {
+		if _, ok := f.(*fdio.Pipe); ok {
+			return off, ESPIPE
 		}
 	}
 	return off, err
diff --git a/src/syscall/zx/dispatch/dispatcher.go b/src/syscall/zx/dispatch/dispatcher.go
index e607ae6..0652a08 100644
--- a/src/syscall/zx/dispatch/dispatcher.go
+++ b/src/syscall/zx/dispatch/dispatcher.go
@@ -181,9 +181,9 @@
 
 		// If we fail to re-arm, notify the handler of what happened.
 		if err != nil {
-			zxErr := err.(*zx.Error)
-			result = wc.callback(d, zxErr.Status, nil)
-			assertWaitResult(result, zxErr.Status)
+			status := err.(*zx.Error).Status
+			result = wc.callback(d, status, nil)
+			assertWaitResult(result, status)
 		}
 	case WaitFinished:
 		d.mu.Lock()
diff --git a/src/syscall/zx/fdio/pipe.go b/src/syscall/zx/fdio/pipe.go
index 03724b1..d8468198 100644
--- a/src/syscall/zx/fdio/pipe.go
+++ b/src/syscall/zx/fdio/pipe.go
@@ -68,34 +68,32 @@
 	return nil, nil, &zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
 }
 
-func (f *Pipe) Read(data []byte) (n int, err error) {
+func (f *Pipe) Read(data []byte) (int, error) {
 	for {
-		n, err = f.s.Read(data, 0)
-		if err == nil {
-			return n, nil
-		}
-		mxerr, ok := err.(*zx.Error)
-		if !ok {
-			return n, err
-		}
-		switch mxerr.Status {
-		case zx.ErrPeerClosed:
-			return 0, zx.EOF
-		case zx.ErrShouldWait:
-			pending, err := f.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
-			if err != nil {
-				return 0, err
+		n, err := f.s.Read(data, 0)
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrPeerClosed:
+					return 0, zx.EOF
+				case zx.ErrShouldWait:
+					pending, err := f.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+					if err != nil {
+						return 0, err
+					}
+					if pending&zx.SignalSocketReadable != 0 {
+						continue
+					}
+					if pending&zx.SignalSocketPeerClosed != 0 {
+						return 0, zx.EOF
+					}
+					// impossible
+					return 0, &zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+				}
 			}
-			if pending&zx.SignalSocketReadable != 0 {
-				continue
-			}
-			if pending&zx.SignalSocketPeerClosed != 0 {
-				return 0, zx.EOF
-			}
-			// impossible
-			return 0, &zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+			return 0, err
 		}
-		return 0, err
+		return n, nil
 	}
 }
 
@@ -103,34 +101,32 @@
 	return 0, &zx.Error{Status: zx.ErrNotSupported, Text: "fdio.Pipe"}
 }
 
-func (f *Pipe) Write(data []byte) (n int, err error) {
+func (f *Pipe) Write(data []byte) (int, error) {
 	for {
-		n, err = f.s.Write(data, 0)
-		if err == nil {
-			return n, nil
-		}
-		mxerr, ok := err.(*zx.Error)
-		if !ok {
-			return n, err
-		}
-		switch mxerr.Status {
-		case zx.ErrPeerClosed:
-			return 0, zx.EPIPE
-		case zx.ErrShouldWait:
-			pending, err := f.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
-			if err != nil {
-				return 0, err
+		n, err := f.s.Write(data, 0)
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrPeerClosed:
+					return 0, zx.EPIPE
+				case zx.ErrShouldWait:
+					pending, err := f.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+					if err != nil {
+						return 0, err
+					}
+					if pending&zx.SignalSocketWritable != 0 {
+						continue
+					}
+					if pending&zx.SignalSocketPeerClosed != 0 {
+						return 0, zx.EPIPE
+					}
+					// impossible
+					return 0, &zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+				}
 			}
-			if pending&zx.SignalSocketWritable != 0 {
-				continue
-			}
-			if pending&zx.SignalSocketPeerClosed != 0 {
-				return 0, zx.EPIPE
-			}
-			// impossible
-			return 0, &zx.Error{Status: zx.ErrInternal, Text: "fdio.Pipe"}
+			return 0, err
 		}
-		return 0, err
+		return n, nil
 	}
 }
 
diff --git a/src/syscall/zx/fidl/bindings.go b/src/syscall/zx/fidl/bindings.go
index 978e3ed..85b074d 100644
--- a/src/syscall/zx/fidl/bindings.go
+++ b/src/syscall/zx/fidl/bindings.go
@@ -138,8 +138,7 @@
 
 	nb, nh, err := b.Channel.Read(respb, resph, 0)
 	if err != nil {
-		zxErr, ok := err.(*zx.Error)
-		if ok && zxErr.Status == zx.ErrShouldWait {
+		if err, ok := err.(*zx.Error); ok && err.Status == zx.ErrShouldWait {
 			return true, nil
 		}
 		return false, err
@@ -198,11 +197,10 @@
 // called with the binding's mutex set.
 func (b *Binding) close() error {
 	if err := d.CancelWait(*b.id); err != nil {
-		zxErr, ok := err.(*zx.Error)
 		// If it just says that the ID isn't found, there are cases where this is
 		// a reasonable error (particularly when we're in the middle of handling
 		// a signal from the dispatcher).
-		if !ok || zxErr.Status != zx.ErrNotFound {
+		if err, ok := err.(*zx.Error); !ok || err.Status != zx.ErrNotFound {
 			// Attempt to close the channel if we hit a more serious error.
 			b.Channel.Close()
 			return err
diff --git a/src/syscall/zx/handle.go b/src/syscall/zx/handle.go
index 5e77328..a832c0b 100644
--- a/src/syscall/zx/handle.go
+++ b/src/syscall/zx/handle.go
@@ -43,26 +43,25 @@
 	return (*Handle)(s)
 }
 
-func (s *Socket) Read(data []byte, flags uint32) (n int, err error) {
-	var actual uint
-	var p unsafe.Pointer
+func bytesPtr(data []byte) unsafe.Pointer {
 	if len(data) > 0 {
-		p = unsafe.Pointer(&data[0])
+		return unsafe.Pointer(&data[0])
 	}
-	status := sys_socket_read(Handle(*s), flags, p, uint(len(data)), &actual)
+	return unsafe.Pointer(uintptr(0))
+}
+
+func (s *Socket) Read(data []byte, flags uint32) (int, error) {
+	var actual uint
+	status := sys_socket_read(Handle(*s), flags, bytesPtr(data), uint(len(data)), &actual)
 	if status != ErrOk {
 		return int(actual), &Error{Status: status, Text: "zx.Socket.Read"}
 	}
 	return int(actual), nil
 }
 
-func (s *Socket) Write(data []byte, flags uint32) (n int, err error) {
-	var p unsafe.Pointer
-	if len(data) > 0 {
-		p = unsafe.Pointer(&data[0])
-	}
+func (s *Socket) Write(data []byte, flags uint32) (int, error) {
 	var actual uint
-	status := sys_socket_write(Handle(*s), flags, p, uint(len(data)), &actual)
+	status := sys_socket_write(Handle(*s), flags, bytesPtr(data), uint(len(data)), &actual)
 	if status != ErrOk {
 		return int(actual), &Error{Status: status, Text: "zx.Socket.Write"}
 	}
@@ -90,7 +89,7 @@
 	return err
 }
 
-func (s *Socket) Shutdown(flags uint32) (err error) {
+func (s *Socket) Shutdown(flags uint32) error {
 	status := Sys_socket_shutdown(Handle(*s), flags)
 	if status != ErrOk {
 		return &Error{Status: status, Text: "zx.Socket.Shutdown"}
@@ -98,7 +97,7 @@
 	return nil
 }
 
-func NewSocket(flags uint32) (s0, s1 Socket, err error) {
+func NewSocket(flags uint32) (Socket, Socket, error) {
 	var h0, h1 Handle
 	if status := sys_socket_create(flags, &h0, &h1); status != ErrOk {
 		return Socket(HandleInvalid), Socket(HandleInvalid), &Error{Status: status, Text: "zx.Socket"}
@@ -108,7 +107,7 @@
 
 type Event Handle
 
-func NewEvent(options uint32) (e Event, err error) {
+func NewEvent(options uint32) (Event, error) {
 	var h Handle
 	if status := Sys_event_create(options, &h); status != ErrOk {
 		return Event(HandleInvalid), &Error{Status: status, Text: "zx.Event"}
@@ -166,34 +165,27 @@
 	return nil
 }
 
-func (h *Handle) GetInfo(topic uint32, data []byte) (actual, avail uint, err error) {
+func (h *Handle) GetInfo(topic uint32, data []byte) (actual, avail uint, _ error) {
 	dataBytes := uint(len(data))
-	var dataPtr unsafe.Pointer
-	if dataBytes > 0 {
-		dataPtr = unsafe.Pointer(&data[0])
+	if status := Sys_object_get_info(*h, topic, bytesPtr(data), dataBytes, &actual, &avail); status != ErrOk {
+		return 0, 0, &Error{Status: status, Text: "zx.Handle.GetInfo"}
 	}
-	if status := Sys_object_get_info(*h, topic, dataPtr, dataBytes, &actual, &avail); status != ErrOk {
-		err = &Error{Status: status, Text: "zx.Handle.GetInfo"}
-	}
-	return
+	return actual, avail, nil
 }
 
-func (h *Handle) GetInfoHandleBasic() (info InfoHandleBasic, err error) {
+func (h *Handle) GetInfoHandleBasic() (InfoHandleBasic, error) {
+	var info InfoHandleBasic
 	dataBytes := uint(unsafe.Sizeof(info))
 	dataPtr := unsafe.Pointer(&info)
 	if status := Sys_object_get_info(*h, ObjectInfoHandleBasic, dataPtr, dataBytes, nil, nil); status != ErrOk {
-		err = &Error{Status: status, Text: "zx.Handle.GetInfoHandleBasic"}
+		return info, &Error{Status: status, Text: "zx.Handle.GetInfoHandleBasic"}
 	}
-	return
+	return info, nil
 }
 
 func (h *Handle) GetProperty(property uint32, data []byte) error {
 	var numBytes = uint(len(data))
-	var dataPtr unsafe.Pointer
-	if numBytes > 0 {
-		dataPtr = unsafe.Pointer(&data[0])
-	}
-	if status := Sys_object_get_property(*h, property, dataPtr, numBytes); status != ErrOk {
+	if status := Sys_object_get_property(*h, property, bytesPtr(data), numBytes); status != ErrOk {
 		return &Error{Status: status, Text: "zx.Handle.GetProperty"}
 	}
 	return nil
@@ -201,11 +193,7 @@
 
 func (h *Handle) SetProperty(property uint32, data []byte) error {
 	var numBytes = uint(len(data))
-	var dataPtr unsafe.Pointer
-	if numBytes > 0 {
-		dataPtr = unsafe.Pointer(&data[0])
-	}
-	if status := Sys_object_set_property(*h, property, dataPtr, numBytes); status != ErrOk {
+	if status := Sys_object_set_property(*h, property, bytesPtr(data), numBytes); status != ErrOk {
 		return &Error{Status: status, Text: "zx.Handle.SetProperty"}
 	}
 	return nil
@@ -216,7 +204,11 @@
 }
 
 func WaitMany(items []WaitItem, timeout Time) error {
-	if status := sys_object_wait_many(&items[0], uint(len(items)), timeout); status != ErrOk {
+	var ptr *WaitItem
+	if len(items) > 0 {
+		ptr = &items[0]
+	}
+	if status := sys_object_wait_many(ptr, uint(len(items)), timeout); status != ErrOk {
 		return &Error{Status: status, Text: "zx.Handle.WaitMany"}
 	}
 	return nil
@@ -240,75 +232,48 @@
 	return err
 }
 
-func (c *Channel) Read(data []byte, handles []Handle, flags uint32) (numBytes, numHandles uint32, err error) {
+func handlePtr(data []Handle) *Handle {
+	if len(data) > 0 {
+		return &data[0]
+	}
+	return nil
+}
+
+func (c *Channel) Read(data []byte, handles []Handle, flags uint32) (numBytes, numHandles uint32, _ error) {
 	numBytes = uint32(len(data))
 	numHandles = uint32(len(handles))
-	var dataPtr unsafe.Pointer
-	if len(data) > 0 {
-		dataPtr = unsafe.Pointer(&data[0])
+	if status := sys_channel_read(Handle(*c), flags, bytesPtr(data), handlePtr(handles), numBytes, numHandles, &numBytes, &numHandles); status != ErrOk {
+		return 0, 0, &Error{Status: status, Text: "zx.Channel.Read"}
 	}
-	var handlePtr *Handle
-	if len(handles) > 0 {
-		handlePtr = &handles[0]
-	}
-	if status := sys_channel_read(Handle(*c), flags, dataPtr, handlePtr, numBytes, numHandles, &numBytes, &numHandles); status != ErrOk {
-		err = &Error{Status: status, Text: "zx.Channel.Read"}
-	}
-	return numBytes, numHandles, err
+	return numBytes, numHandles, nil
 }
 
 func (c *Channel) Write(data []byte, handles []Handle, flags uint32) error {
-	var dataPtr unsafe.Pointer
-	if len(data) > 0 {
-		dataPtr = unsafe.Pointer(&data[0])
-	}
-	var handlePtr *Handle
-	if len(handles) > 0 {
-		handlePtr = &handles[0]
-	}
-	status := sys_channel_write(Handle(*c), flags, dataPtr, uint32(len(data)), handlePtr, uint32(len(handles)))
-	if status != ErrOk {
+	if status := sys_channel_write(Handle(*c), flags, bytesPtr(data), uint32(len(data)), handlePtr(handles), uint32(len(handles))); status != ErrOk {
 		return &Error{Status: status, Text: "zx.Channel.Write"}
 	}
 	return nil
 }
 
-func (c *Channel) Call(flags uint32, deadline Time, wData []byte, wHandles []Handle, rData []byte, rHandles []Handle) (actualBytes, actualHandles uint32, err error) {
-	var writeDataPtr uintptr
-	if len(wData) > 0 {
-		writeDataPtr = uintptr(unsafe.Pointer(&wData[0]))
-	}
-	var writeHandlePtr *Handle
-	if len(wHandles) > 0 {
-		writeHandlePtr = &wHandles[0]
-	}
-	var readDataPtr uintptr
-	if len(rData) > 0 {
-		readDataPtr = uintptr(unsafe.Pointer(&rData[0]))
-	}
-	var readHandlePtr *Handle
-	if len(rHandles) > 0 {
-		readHandlePtr = &rHandles[0]
-	}
+func (c *Channel) Call(flags uint32, deadline Time, wData []byte, wHandles []Handle, rData []byte, rHandles []Handle) (actualBytes, actualHandles uint32, _ error) {
 	args := &ChannelCallArgs{
-		WriteBytes:      writeDataPtr,
-		WriteHandles:    writeHandlePtr,
-		ReadBytes:       readDataPtr,
-		ReadHandles:     readHandlePtr,
+		WriteBytes:      bytesPtr(wData),
+		WriteHandles:    handlePtr(wHandles),
+		ReadBytes:       bytesPtr(rData),
+		ReadHandles:     handlePtr(rHandles),
 		WriteNumBytes:   uint32(len(wData)),
 		WriteNumHandles: uint32(len(wHandles)),
 		ReadNumBytes:    uint32(len(rData)),
 		ReadNumHandles:  uint32(len(rHandles)),
 	}
 
-	status := Sys_channel_call(Handle(*c), flags, deadline, args, &actualBytes, &actualHandles)
-	if status != ErrOk {
-		err = &Error{Status: status, Text: "zx.Channel.Call"}
+	if status := Sys_channel_call(Handle(*c), flags, deadline, args, &actualBytes, &actualHandles); status != ErrOk {
+		return 0, 0, &Error{Status: status, Text: "zx.Channel.Call"}
 	}
-	return actualBytes, actualHandles, err
+	return actualBytes, actualHandles, nil
 }
 
-func NewChannel(flags uint32) (c0, c1 Channel, err error) {
+func NewChannel(flags uint32) (Channel, Channel, error) {
 	var h0, h1 Handle
 	if status := sys_channel_create(flags, &h0, &h1); status != ErrOk {
 		return Channel(HandleInvalid), Channel(HandleInvalid), &Error{Status: status, Text: "zx.Channel"}
@@ -436,14 +401,14 @@
 }
 
 func (vmo *VMO) Read(b []byte, offset uint64) error {
-	if status := sys_vmo_read(Handle(*vmo), unsafe.Pointer(&b[0]), offset, uint(len(b))); status != ErrOk {
+	if status := sys_vmo_read(Handle(*vmo), bytesPtr(b), offset, uint(len(b))); status != ErrOk {
 		return &Error{Status: status, Text: "zx.VMO.Read"}
 	}
 	return nil
 }
 
 func (vmo *VMO) Write(b []byte, offset uint64) error {
-	if status := sys_vmo_write(Handle(*vmo), unsafe.Pointer(&b[0]), offset, uint(len(b))); status != ErrOk {
+	if status := sys_vmo_write(Handle(*vmo), bytesPtr(b), offset, uint(len(b))); status != ErrOk {
 		return &Error{Status: status, Text: "zx.VMO.Write"}
 	}
 	return nil
@@ -465,7 +430,7 @@
 }
 
 func (vmo *VMO) OpRange(op uint32, offset, size uint64, b []byte) error {
-	if status := sys_vmo_op_range(Handle(*vmo), op, offset, size, unsafe.Pointer(&b[0]), uint(len(b))); status != ErrOk {
+	if status := sys_vmo_op_range(Handle(*vmo), op, offset, size, bytesPtr(b), uint(len(b))); status != ErrOk {
 		return &Error{Status: status, Text: "zx.VMO.OpRange"}
 	}
 	return nil
@@ -495,40 +460,32 @@
 	return nil
 }
 
-var mapErr error = &Error{Status: 1, Text: "zx.VMAR.Map"}
-
-func (v VMAR) Map(vmarOffset uint64, vmo VMO, vmoOffset, len uint64, flags VMFlag) (addr uintptr, err error) {
-	status := Sys_vmar_map(Handle(v), flags, uint64(vmarOffset), Handle(vmo), vmoOffset, uint64(len), (*Vaddr)(&addr))
-	if status != ErrOk {
-		println("zx.VMAR.Map failed: status: ", status)
-		return 0, mapErr
+func (v VMAR) Map(vmarOffset uint64, vmo VMO, vmoOffset, len uint64, flags VMFlag) (Vaddr, error) {
+	var addr Vaddr
+	if status := Sys_vmar_map(Handle(v), flags, uint64(vmarOffset), Handle(vmo), vmoOffset, uint64(len), &addr); status != ErrOk {
+		return 0, &Error{Status: status, Text: "zx.VMAR.Map"}
 	}
 	return addr, nil
 }
 
-var unmapErr error = &Error{Status: 1, Text: "zx.VMAR.Unmap"}
-
-func (v VMAR) Unmap(addr uintptr, len uint64) error {
-	status := Sys_vmar_unmap(Handle(v), Vaddr(addr), uint64(len))
-	if status != ErrOk {
-		println(status)
-		return unmapErr
+func (v VMAR) Unmap(addr Vaddr, len uint64) error {
+	if status := Sys_vmar_unmap(Handle(v), addr, uint64(len)); status != ErrOk {
+		return &Error{Status: status, Text: "zx.VMAR.Unmap"}
 	}
 	return nil
 }
 
-func (v VMAR) Protect(addr uintptr, len uint64, flags VMFlag) error {
-	status := Sys_vmar_protect(Handle(v), flags, Vaddr(addr), uint64(len))
-	if status != ErrOk {
+func (v VMAR) Protect(addr Vaddr, len uint64, flags VMFlag) error {
+	if status := Sys_vmar_protect(Handle(v), flags, addr, uint64(len)); status != ErrOk {
 		return &Error{Status: status, Text: "zx.VMAR.Protect"}
 	}
 	return nil
 }
 
-func NewVMAR(parent VMAR, offset, size uint64, flags VMFlag) (child VMAR, addr uintptr, err error) {
+func NewVMAR(parent VMAR, offset, size uint64, flags VMFlag) (VMAR, Vaddr, error) {
 	var childHandle Handle
-	status := sys_vmar_allocate(Handle(parent), flags, uint64(offset), uint64(size), &childHandle, (*Vaddr)(&addr))
-	if status != ErrOk {
+	var addr Vaddr
+	if status := sys_vmar_allocate(Handle(parent), flags, uint64(offset), uint64(size), &childHandle, &addr); status != ErrOk {
 		return 0, 0, &Error{Status: status, Text: "zx.NewVMAR"}
 	}
 	return VMAR(childHandle), addr, nil
@@ -549,36 +506,29 @@
 	return (*Handle)(l)
 }
 
-func (l Log) Write(b []byte) (n int, err error) {
-	var p unsafe.Pointer
-	if len(b) > 0 {
-		p = unsafe.Pointer(&b[0])
-	}
-
-	status := Sys_debuglog_write(Handle(l), 0, p, uint(len(b)))
-	if status != ErrOk {
+func (l Log) Write(b []byte) (int, error) {
+	if status := Sys_debuglog_write(Handle(l), 0, bytesPtr(b), uint(len(b))); status != ErrOk {
 		return 0, &Error{Status: status, Text: "zx.Log.Write"}
 	}
 	return len(b), nil
 }
 
-func (l Log) Read(b []byte) (n int, err error) {
-	status := Sys_debuglog_read(Handle(l), 0, unsafe.Pointer(&b[0]), uint(len(b)))
-	if status != ErrOk {
+func (l Log) Read(b []byte) (int, error) {
+	if status := Sys_debuglog_read(Handle(l), 0, bytesPtr(b), uint(len(b))); status != ErrOk {
 		return 0, &Error{Status: status, Text: "zx.Log.Read"}
 	}
 	return len(b), nil
 }
 
-func (l *Log) Close() (err error) {
+func (l *Log) Close() error {
 	h := Handle(*l)
-	err = h.Close()
+	err := h.Close()
 	*l = Log(HandleInvalid)
 	return err
 }
 
 func RandRead(b []byte) {
-	Sys_cprng_draw(unsafe.Pointer(&b[0]), uint(len(b)))
+	Sys_cprng_draw(bytesPtr(b), uint(len(b)))
 }
 
 // Error is a Status with associated error text.
diff --git a/src/syscall/zx/mxerror/mxerror.go b/src/syscall/zx/mxerror/mxerror.go
deleted file mode 100644
index 64422c0..0000000
--- a/src/syscall/zx/mxerror/mxerror.go
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// +build fuchsia
-
-package mxerror
-
-import (
-	"syscall/zx"
-)
-
-// Status extracts an zx.Status from an error.
-func Status(err error) zx.Status {
-	if err == nil {
-		return zx.ErrOk
-	}
-	switch err := err.(type) {
-	case *zx.Error:
-		return err.Status
-	}
-	return zx.ErrInternal
-}
diff --git a/src/syscall/zx/types.go b/src/syscall/zx/types.go
index ecb34af..02fd558 100644
--- a/src/syscall/zx/types.go
+++ b/src/syscall/zx/types.go
@@ -141,9 +141,9 @@
 func (*RrecIOPort) rrec() {}
 
 type ChannelCallArgs struct {
-	WriteBytes      uintptr
+	WriteBytes      unsafe.Pointer
 	WriteHandles    *Handle
-	ReadBytes       uintptr
+	ReadBytes       unsafe.Pointer
 	ReadHandles     *Handle
 	WriteNumBytes   uint32
 	WriteNumHandles uint32
diff --git a/src/syscall/zx/zxsocket/socket.go b/src/syscall/zx/zxsocket/socket.go
index f9d5345..e320759 100644
--- a/src/syscall/zx/zxsocket/socket.go
+++ b/src/syscall/zx/zxsocket/socket.go
@@ -12,7 +12,6 @@
 	"syscall/zx"
 	"syscall/zx/fdio"
 	fidlIo "syscall/zx/io"
-	"syscall/zx/mxerror"
 	"syscall/zx/mxnet"
 	"syscall/zx/net"
 	"syscall/zx/zxwait"
@@ -34,7 +33,7 @@
 	}
 }
 
-func (s *Socket) Wait(signals zx.Signals, timeout zx.Time) (observed zx.Signals, err error) {
+func (s *Socket) Wait(signals zx.Signals, timeout zx.Time) (zx.Signals, error) {
 	return zxwait.Wait(zx.Handle(s.Socket), signals, timeout)
 }
 
@@ -99,32 +98,36 @@
 		n = copy(data, b)
 		return n, err
 	}
-	// c.f. mxsio_read_stream in zircon/system/ulib/fdio/remoteio.c
+	// c.f. zxs_recvmsg_stream in zircon/system/ulib/zxs/zxs.cpp
 	for {
-		n, err = s.Socket.Read(data, 0)
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return n, nil
-		case zx.ErrPeerClosed:
-			return 0, io.EOF
-		case zx.ErrShouldWait:
-			obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
-			switch mxerror.Status(err) {
-			case zx.ErrOk:
-				switch {
-				case obs&zx.SignalSocketReadable != 0:
-					continue
-				case obs&zx.SignalSocketPeerClosed != 0:
+		n, err := s.Socket.Read(data, 0)
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrPeerClosed:
 					return 0, io.EOF
+				case zx.ErrShouldWait:
+					obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed, zx.TimensecInfinite)
+					if err != nil {
+						if err, ok := err.(*zx.Error); ok {
+							switch err.Status {
+							case zx.ErrBadHandle, zx.ErrCanceled:
+								return 0, io.EOF
+							}
+						}
+						return 0, err
+					}
+					switch {
+					case obs&zx.SignalSocketReadable != 0:
+						continue
+					case obs&zx.SignalSocketPeerClosed != 0:
+						return 0, io.EOF
+					}
 				}
-			case zx.ErrBadHandle, zx.ErrCanceled:
-				return 0, io.EOF
-			default:
-				return 0, err
 			}
-		default:
 			return 0, err
 		}
+		return n, nil
 	}
 }
 
@@ -140,32 +143,33 @@
 		return n, err
 	}
 
-	// c.f. zxsio_write_stream
+	// c.f. zxsio_sendmsg_stream
 	var total int
 	for {
 		n, err := s.Socket.Write(data, 0)
 		total += n
-
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return total, nil
-		case zx.ErrShouldWait:
-			obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
-			if err != nil {
-				return total, err
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrShouldWait:
+					obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
+					if err != nil {
+						return total, err
+					}
+					if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
+						return total, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.Write"}
+					}
+					if obs&zx.SignalSocketWritable != 0 {
+						data = data[n:]
+						continue
+					}
+					// This case should be impossible:
+					return total, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.Write(impossible state)"}
+				}
 			}
-			if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
-				return total, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.Write"}
-			}
-			if obs&zx.SignalSocketWritable != 0 {
-				data = data[n:]
-				continue
-			}
-			// This case should be impossible:
-			return total, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.Write(impossible state)"}
-		default:
 			return total, err
 		}
+		return total, nil
 	}
 }
 
@@ -232,28 +236,29 @@
 func (s *Socket) recvMsg(data []byte) (int, error) {
 	for {
 		n, err := s.Socket.Read(data, 0)
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return n, err
-		case zx.ErrShouldWait:
-			if n != 0 {
-				return n, &zx.Error{Status: zx.ErrInternal, Text: "zsocket.Socket.recvMsg(datagram short-read)"}
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrShouldWait:
+					if n != 0 {
+						return n, &zx.Error{Status: zx.ErrInternal, Text: "zsocket.Socket.recvMsg(datagram short-read)"}
+					}
+					obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed|zx.SignalSocketReadDisabled, zx.TimensecInfinite)
+					if err != nil {
+						return n, err
+					}
+					if obs&zx.SignalSocketReadable != 0 {
+						continue
+					}
+					if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketReadDisabled != 0 {
+						return n, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.recvMsg"}
+					}
+					return n, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.recvMsg(impossible state))"}
+				}
 			}
-
-			obs, err := s.Wait(zx.SignalSocketReadable|zx.SignalSocketPeerClosed|zx.SignalSocketReadDisabled, zx.TimensecInfinite)
-			if err != nil {
-				return n, err
-			}
-			if obs&zx.SignalSocketReadable != 0 {
-				continue
-			}
-			if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketReadDisabled != 0 {
-				return n, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.recvMsg"}
-			}
-			return n, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.recvMsg"}
-		default:
 			return n, err
 		}
+		return n, nil
 	}
 }
 
@@ -267,31 +272,33 @@
 
 	for {
 		n, err := s.Socket.Write(data, 0)
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return len(b), nil
-		case zx.ErrShouldWait:
-			if n != 0 {
-				return n, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(datagram short-write)"}
-			}
+		if err != nil {
+			if err, ok := err.(*zx.Error); ok {
+				switch err.Status {
+				case zx.ErrShouldWait:
+					if n != 0 {
+						return n, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(datagram short-write)"}
+					}
 
-			obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
-			if err != nil {
-				return 0, err
+					obs, err := s.Wait(zx.SignalSocketWritable|zx.SignalSocketPeerClosed|zx.SignalSocketWriteDisabled, zx.TimensecInfinite)
+					if err != nil {
+						return 0, err
+					}
+					if obs&zx.SignalSocketWritable != 0 {
+						continue
+					}
+					if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
+						return 0, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.SendMsg"}
+					}
+					return 0, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(impossible state)"}
+				}
 			}
-			if obs&zx.SignalSocketWritable != 0 {
-				continue
-			}
-			if obs&zx.SignalSocketPeerClosed != 0 || obs&zx.SignalSocketWriteDisabled != 0 {
-				return 0, &zx.Error{Status: zx.ErrPeerClosed, Text: "zxsocket.Socket.SendMsg"}
-			}
-			return 0, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(impossible state)"}
-		default:
 			if n != 0 {
 				return n, &zx.Error{Status: zx.ErrInternal, Text: "zxsocket.Socket.SendMsg(datagram short-write)"}
 			}
 			return 0, err
 		}
+		return len(b), nil
 	}
 }
 
@@ -300,54 +307,3 @@
 func (s *Socket) SetDgram() {
 	s.dgram = true
 }
-
-func ReadControl(s zx.Socket, data []byte) (n int, err error) {
-	// c.f. zxsocket._read_control in zircon/system/ulib/fdio/remoteio.c
-	for {
-		n, err = s.Read(data, zx.SocketControl)
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return n, nil
-		case zx.ErrPeerClosed:
-			return 0, io.EOF
-		case zx.ErrShouldWait:
-			obs, err := zxwait.Wait(
-				zx.Handle(s),
-				zx.SignalSocketControlReadable|zx.SignalSocketPeerClosed,
-				zx.TimensecInfinite,
-			)
-			switch mxerror.Status(err) {
-			case zx.ErrOk:
-				switch {
-				case obs&zx.SignalSocketControlReadable != 0:
-					continue
-				case obs&zx.SignalSocketPeerClosed != 0:
-					return 0, io.EOF
-				}
-			case zx.ErrBadHandle, zx.ErrCanceled:
-				return 0, io.EOF
-			default:
-				return 0, err
-			}
-		default:
-			return 0, err
-		}
-	}
-}
-
-func WriteControl(s zx.Socket, data []byte) (int, error) {
-	// c.f. zxsocket._write_control
-	for {
-		n, err := s.Write(data, zx.SocketControl)
-		switch mxerror.Status(err) {
-		case zx.ErrOk:
-			return n, nil
-		case zx.ErrShouldWait:
-			_, err := zxwait.Wait(zx.Handle(s), zx.SignalSocketControlWriteable, zx.TimensecInfinite)
-			if err != nil {
-				return n, err
-			}
-			continue
-		}
-	}
-}
diff --git a/src/syscall/zx/zxwait/zxwait.go b/src/syscall/zx/zxwait/zxwait.go
index de286eb..6647ad9 100644
--- a/src/syscall/zx/zxwait/zxwait.go
+++ b/src/syscall/zx/zxwait/zxwait.go
@@ -26,9 +26,10 @@
 // Semantically it is equivalent to calling the WaitOne method on a zx.Handle.
 // However it is not implemented with zx_object_wait_one, instead it uses
 // zx_object_wait_async and a port to wait for signals.
-func Wait(handle zx.Handle, signals zx.Signals, timeout zx.Time) (observed zx.Signals, err error) {
+func Wait(handle zx.Handle, signals zx.Signals, timeout zx.Time) (zx.Signals, error) {
 	// TODO: support finite timeouts.
 	if timeout != zx.TimensecInfinite {
+		var observed zx.Signals
 		if status := zx.Sys_object_wait_one(handle, signals, timeout, &observed); status != zx.ErrOk {
 			return observed, &zx.Error{Status: status, Text: "zxwait.Wait"}
 		}
@@ -118,7 +119,7 @@
 // Wait waits for signals on handle.
 //
 // See the package function Wait for more commentary.
-func (w *waiter) Wait(handle zx.Handle, signals zx.Signals) (observed zx.Signals, err error) {
+func (w *waiter) Wait(handle zx.Handle, signals zx.Signals) (zx.Signals, error) {
 	var waiting *waitingG
 
 	w.mu.Lock()
@@ -138,7 +139,7 @@
 	pkt.Signal().Trigger = signals
 
 	const ZX_WAIT_ASYNC_ONCE = 0
-	if err = w.port.WaitAsync(handle, pkt.Hdr.Key, signals, ZX_WAIT_ASYNC_ONCE); err != nil {
+	if err := w.port.WaitAsync(handle, pkt.Hdr.Key, signals, ZX_WAIT_ASYNC_ONCE); err != nil {
 		return 0, err
 	}