[syserror] Split usermem package

Split usermem package to help remove syserror dependency in go_marshal.
New hostarch package contains code not dependent on syserror.

PiperOrigin-RevId: 365651233

5 files changed, 43 insertions, 41 deletions

diff --git a/pkg/marshal/BUILD b/pkg/marshal/BUILD
index aac0161fa..7cd89e639 100644
--- a/pkg/marshal/BUILD
+++ b/pkg/marshal/BUILD
@@ -11,5 +11,5 @@ go_library(
     visibility = [
         "//:sandbox",
     ],
-    deps = ["//pkg/usermem"],
+    deps = ["//pkg/hostarch"],
 )
diff --git a/pkg/marshal/marshal.go b/pkg/marshal/marshal.go
index d8cb44b40..eb036feae 100644
--- a/pkg/marshal/marshal.go
+++ b/pkg/marshal/marshal.go
@@ -23,7 +23,7 @@ package marshal
 import (
 	"io"
 
-	"gvisor.dev/gvisor/pkg/usermem"
+	"gvisor.dev/gvisor/pkg/hostarch"
 )
 
 // CopyContext defines the memory operations required to marshal to and from
@@ -36,11 +36,11 @@ type CopyContext interface {
 
 	// CopyOutBytes writes the contents of b to the task's memory. See
 	// kernel.CopyOutBytes.
-	CopyOutBytes(addr usermem.Addr, b []byte) (int, error)
+	CopyOutBytes(addr hostarch.Addr, b []byte) (int, error)
 
 	// CopyInBytes reads the contents of the task's memory to b. See
 	// kernel.CopyInBytes.
-	CopyInBytes(addr usermem.Addr, b []byte) (int, error)
+	CopyInBytes(addr hostarch.Addr, b []byte) (int, error)
 }
 
 // Marshallable represents operations on a type that can be marshalled to and
@@ -108,7 +108,7 @@ type Marshallable interface {
 	// If the copy-in from the task memory is only partially successful, CopyIn
 	// should still attempt to deserialize as much data as possible. See comment
 	// for UnmarshalBytes.
-	CopyIn(cc CopyContext, addr usermem.Addr) (int, error)
+	CopyIn(cc CopyContext, addr hostarch.Addr) (int, error)
 
 	// CopyOut serializes a Marshallable type to a task's memory. This may only
 	// be called from a task goroutine. This is more efficient than calling
@@ -119,7 +119,7 @@ type Marshallable interface {
 	// The copy-out to the task memory may be partially successful, in which
 	// case CopyOut returns how much data was serialized. See comment for
 	// MarshalBytes for implications.
-	CopyOut(cc CopyContext, addr usermem.Addr) (int, error)
+	CopyOut(cc CopyContext, addr hostarch.Addr) (int, error)
 
 	// CopyOutN is like CopyOut, but explicitly requests a partial
 	// copy-out. Note that this may yield unexpected results for non-packed
@@ -127,7 +127,7 @@ type Marshallable interface {
 	// comment on MarshalBytes.
 	//
 	// The limit must be less than or equal to SizeBytes().
-	CopyOutN(cc CopyContext, addr usermem.Addr, limit int) (int, error)
+	CopyOutN(cc CopyContext, addr hostarch.Addr, limit int) (int, error)
 }
 
 // go-marshal generates additional functions for a type based on additional
@@ -157,10 +157,10 @@ type Marshallable interface {
 // func UnmarshalUnsafeFooSlice(dst []Foo, src []byte) (int, error) { ... }
 //
 // // CopyFooSliceIn copies in a slice of Foo objects from the task's memory.
-// func CopyFooSliceIn(cc marshal.CopyContext, addr usermem.Addr, dst []Foo) (int, error) { ... }
+// func CopyFooSliceIn(cc marshal.CopyContext, addr hostarch.Addr, dst []Foo) (int, error) { ... }
 //
 // // CopyFooSliceIn copies out a slice of Foo objects to the task's memory.
-// func CopyFooSliceOut(cc marshal.CopyContext, addr usermem.Addr, src []Foo) (int, error) { ... }
+// func CopyFooSliceOut(cc marshal.CopyContext, addr hostarch.Addr, src []Foo) (int, error) { ... }
 //
 // The name of the functions are of the format "Copy%sIn" and "Copy%sOut", where
 // %s is the first argument to the slice clause. This directive is not supported
@@ -175,10 +175,10 @@ type Marshallable interface {
 // This is only valid on newtypes on primitives, and causes the generated
 // functions to accept slices of the inner type instead:
 //
-// func CopyInt32SliceIn(cc marshal.CopyContext, addr usermem.Addr, dst []int32) (int, error) { ... }
+// func CopyInt32SliceIn(cc marshal.CopyContext, addr hostarch.Addr, dst []int32) (int, error) { ... }
 //
 // Without "inner", they would instead be:
 //
-// func CopyInt32SliceIn(cc marshal.CopyContext, addr usermem.Addr, dst []Int32) (int, error) { ... }
+// func CopyInt32SliceIn(cc marshal.CopyContext, addr hostarch.Addr, dst []Int32) (int, error) { ... }
 //
 // This may help avoid a cast depending on how the generated functions are used.
diff --git a/pkg/marshal/marshal_impl_util.go b/pkg/marshal/marshal_impl_util.go
index ea75e09f2..9e6a6fa29 100644
--- a/pkg/marshal/marshal_impl_util.go
+++ b/pkg/marshal/marshal_impl_util.go
@@ -17,7 +17,7 @@ package marshal
 import (
 	"io"
 
-	"gvisor.dev/gvisor/pkg/usermem"
+	"gvisor.dev/gvisor/pkg/hostarch"
 )
 
 // StubMarshallable implements the Marshallable interface.
@@ -63,16 +63,16 @@ func (StubMarshallable) UnmarshalUnsafe(src []byte) {
 }
 
 // CopyIn implements Marshallable.CopyIn.
-func (StubMarshallable) CopyIn(cc CopyContext, addr usermem.Addr) (int, error) {
+func (StubMarshallable) CopyIn(cc CopyContext, addr hostarch.Addr) (int, error) {
 	panic("Please implement your own CopyIn function")
 }
 
 // CopyOut implements Marshallable.CopyOut.
-func (StubMarshallable) CopyOut(cc CopyContext, addr usermem.Addr) (int, error) {
+func (StubMarshallable) CopyOut(cc CopyContext, addr hostarch.Addr) (int, error) {
 	panic("Please implement your own CopyOut function")
 }
 
 // CopyOutN implements Marshallable.CopyOutN.
-func (StubMarshallable) CopyOutN(cc CopyContext, addr usermem.Addr, limit int) (int, error) {
+func (StubMarshallable) CopyOutN(cc CopyContext, addr hostarch.Addr, limit int) (int, error) {
 	panic("Please implement your own CopyOutN function")
 }
diff --git a/pkg/marshal/primitive/BUILD b/pkg/marshal/primitive/BUILD
index d77a11c79..190b57c29 100644
--- a/pkg/marshal/primitive/BUILD
+++ b/pkg/marshal/primitive/BUILD
@@ -13,6 +13,7 @@ go_library(
     ],
     deps = [
         "//pkg/context",
+        "//pkg/hostarch",
         "//pkg/marshal",
         "//pkg/usermem",
     ],
diff --git a/pkg/marshal/primitive/primitive.go b/pkg/marshal/primitive/primitive.go
index 4b342de6b..32c8ed138 100644
--- a/pkg/marshal/primitive/primitive.go
+++ b/pkg/marshal/primitive/primitive.go
@@ -20,6 +20,7 @@ import (
 	"io"
 
 	"gvisor.dev/gvisor/pkg/context"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal"
 	"gvisor.dev/gvisor/pkg/usermem"
 )
@@ -102,17 +103,17 @@ func (b *ByteSlice) UnmarshalUnsafe(src []byte) {
 }
 
 // CopyIn implements marshal.Marshallable.CopyIn.
-func (b *ByteSlice) CopyIn(cc marshal.CopyContext, addr usermem.Addr) (int, error) {
+func (b *ByteSlice) CopyIn(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
 	return cc.CopyInBytes(addr, *b)
 }
 
 // CopyOut implements marshal.Marshallable.CopyOut.
-func (b *ByteSlice) CopyOut(cc marshal.CopyContext, addr usermem.Addr) (int, error) {
+func (b *ByteSlice) CopyOut(cc marshal.CopyContext, addr hostarch.Addr) (int, error) {
 	return cc.CopyOutBytes(addr, *b)
 }
 
 // CopyOutN implements marshal.Marshallable.CopyOutN.
-func (b *ByteSlice) CopyOutN(cc marshal.CopyContext, addr usermem.Addr, limit int) (int, error) {
+func (b *ByteSlice) CopyOutN(cc marshal.CopyContext, addr hostarch.Addr, limit int) (int, error) {
 	return cc.CopyOutBytes(addr, (*b)[:limit])
 }
 
@@ -131,7 +132,7 @@ var _ marshal.Marshallable = (*ByteSlice)(nil)
 
 // CopyInt8In is a convenient wrapper for copying in an int8 from the task's
 // memory.
-func CopyInt8In(cc marshal.CopyContext, addr usermem.Addr, dst *int8) (int, error) {
+func CopyInt8In(cc marshal.CopyContext, addr hostarch.Addr, dst *int8) (int, error) {
 	var buf Int8
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -143,14 +144,14 @@ func CopyInt8In(cc marshal.CopyContext, addr usermem.Addr, dst *int8) (int, erro
 
 // CopyInt8Out is a convenient wrapper for copying out an int8 to the task's
 // memory.
-func CopyInt8Out(cc marshal.CopyContext, addr usermem.Addr, src int8) (int, error) {
+func CopyInt8Out(cc marshal.CopyContext, addr hostarch.Addr, src int8) (int, error) {
 	srcP := Int8(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyUint8In is a convenient wrapper for copying in a uint8 from the task's
 // memory.
-func CopyUint8In(cc marshal.CopyContext, addr usermem.Addr, dst *uint8) (int, error) {
+func CopyUint8In(cc marshal.CopyContext, addr hostarch.Addr, dst *uint8) (int, error) {
 	var buf Uint8
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -162,7 +163,7 @@ func CopyUint8In(cc marshal.CopyContext, addr usermem.Addr, dst *uint8) (int, er
 
 // CopyUint8Out is a convenient wrapper for copying out a uint8 to the task's
 // memory.
-func CopyUint8Out(cc marshal.CopyContext, addr usermem.Addr, src uint8) (int, error) {
+func CopyUint8Out(cc marshal.CopyContext, addr hostarch.Addr, src uint8) (int, error) {
 	srcP := Uint8(src)
 	return srcP.CopyOut(cc, addr)
 }
@@ -171,7 +172,7 @@ func CopyUint8Out(cc marshal.CopyContext, addr usermem.Addr, src uint8) (int, er
 
 // CopyInt16In is a convenient wrapper for copying in an int16 from the task's
 // memory.
-func CopyInt16In(cc marshal.CopyContext, addr usermem.Addr, dst *int16) (int, error) {
+func CopyInt16In(cc marshal.CopyContext, addr hostarch.Addr, dst *int16) (int, error) {
 	var buf Int16
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -183,14 +184,14 @@ func CopyInt16In(cc marshal.CopyContext, addr usermem.Addr, dst *int16) (int, er
 
 // CopyInt16Out is a convenient wrapper for copying out an int16 to the task's
 // memory.
-func CopyInt16Out(cc marshal.CopyContext, addr usermem.Addr, src int16) (int, error) {
+func CopyInt16Out(cc marshal.CopyContext, addr hostarch.Addr, src int16) (int, error) {
 	srcP := Int16(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyUint16In is a convenient wrapper for copying in a uint16 from the task's
 // memory.
-func CopyUint16In(cc marshal.CopyContext, addr usermem.Addr, dst *uint16) (int, error) {
+func CopyUint16In(cc marshal.CopyContext, addr hostarch.Addr, dst *uint16) (int, error) {
 	var buf Uint16
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -202,7 +203,7 @@ func CopyUint16In(cc marshal.CopyContext, addr usermem.Addr, dst *uint16) (int,
 
 // CopyUint16Out is a convenient wrapper for copying out a uint16 to the task's
 // memory.
-func CopyUint16Out(cc marshal.CopyContext, addr usermem.Addr, src uint16) (int, error) {
+func CopyUint16Out(cc marshal.CopyContext, addr hostarch.Addr, src uint16) (int, error) {
 	srcP := Uint16(src)
 	return srcP.CopyOut(cc, addr)
 }
@@ -211,7 +212,7 @@ func CopyUint16Out(cc marshal.CopyContext, addr usermem.Addr, src uint16) (int,
 
 // CopyInt32In is a convenient wrapper for copying in an int32 from the task's
 // memory.
-func CopyInt32In(cc marshal.CopyContext, addr usermem.Addr, dst *int32) (int, error) {
+func CopyInt32In(cc marshal.CopyContext, addr hostarch.Addr, dst *int32) (int, error) {
 	var buf Int32
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -223,14 +224,14 @@ func CopyInt32In(cc marshal.CopyContext, addr usermem.Addr, dst *int32) (int, er
 
 // CopyInt32Out is a convenient wrapper for copying out an int32 to the task's
 // memory.
-func CopyInt32Out(cc marshal.CopyContext, addr usermem.Addr, src int32) (int, error) {
+func CopyInt32Out(cc marshal.CopyContext, addr hostarch.Addr, src int32) (int, error) {
 	srcP := Int32(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyUint32In is a convenient wrapper for copying in a uint32 from the task's
 // memory.
-func CopyUint32In(cc marshal.CopyContext, addr usermem.Addr, dst *uint32) (int, error) {
+func CopyUint32In(cc marshal.CopyContext, addr hostarch.Addr, dst *uint32) (int, error) {
 	var buf Uint32
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -242,7 +243,7 @@ func CopyUint32In(cc marshal.CopyContext, addr usermem.Addr, dst *uint32) (int,
 
 // CopyUint32Out is a convenient wrapper for copying out a uint32 to the task's
 // memory.
-func CopyUint32Out(cc marshal.CopyContext, addr usermem.Addr, src uint32) (int, error) {
+func CopyUint32Out(cc marshal.CopyContext, addr hostarch.Addr, src uint32) (int, error) {
 	srcP := Uint32(src)
 	return srcP.CopyOut(cc, addr)
 }
@@ -251,7 +252,7 @@ func CopyUint32Out(cc marshal.CopyContext, addr usermem.Addr, src uint32) (int,
 
 // CopyInt64In is a convenient wrapper for copying in an int64 from the task's
 // memory.
-func CopyInt64In(cc marshal.CopyContext, addr usermem.Addr, dst *int64) (int, error) {
+func CopyInt64In(cc marshal.CopyContext, addr hostarch.Addr, dst *int64) (int, error) {
 	var buf Int64
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -263,14 +264,14 @@ func CopyInt64In(cc marshal.CopyContext, addr usermem.Addr, dst *int64) (int, er
 
 // CopyInt64Out is a convenient wrapper for copying out an int64 to the task's
 // memory.
-func CopyInt64Out(cc marshal.CopyContext, addr usermem.Addr, src int64) (int, error) {
+func CopyInt64Out(cc marshal.CopyContext, addr hostarch.Addr, src int64) (int, error) {
 	srcP := Int64(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyUint64In is a convenient wrapper for copying in a uint64 from the task's
 // memory.
-func CopyUint64In(cc marshal.CopyContext, addr usermem.Addr, dst *uint64) (int, error) {
+func CopyUint64In(cc marshal.CopyContext, addr hostarch.Addr, dst *uint64) (int, error) {
 	var buf Uint64
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -282,14 +283,14 @@ func CopyUint64In(cc marshal.CopyContext, addr usermem.Addr, dst *uint64) (int,
 
 // CopyUint64Out is a convenient wrapper for copying out a uint64 to the task's
 // memory.
-func CopyUint64Out(cc marshal.CopyContext, addr usermem.Addr, src uint64) (int, error) {
+func CopyUint64Out(cc marshal.CopyContext, addr hostarch.Addr, src uint64) (int, error) {
 	srcP := Uint64(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyByteSliceIn is a convenient wrapper for copying in a []byte from the
 // task's memory.
-func CopyByteSliceIn(cc marshal.CopyContext, addr usermem.Addr, dst *[]byte) (int, error) {
+func CopyByteSliceIn(cc marshal.CopyContext, addr hostarch.Addr, dst *[]byte) (int, error) {
 	var buf ByteSlice
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -301,14 +302,14 @@ func CopyByteSliceIn(cc marshal.CopyContext, addr usermem.Addr, dst *[]byte) (in
 
 // CopyByteSliceOut is a convenient wrapper for copying out a []byte to the
 // task's memory.
-func CopyByteSliceOut(cc marshal.CopyContext, addr usermem.Addr, src []byte) (int, error) {
+func CopyByteSliceOut(cc marshal.CopyContext, addr hostarch.Addr, src []byte) (int, error) {
 	srcP := ByteSlice(src)
 	return srcP.CopyOut(cc, addr)
 }
 
 // CopyStringIn is a convenient wrapper for copying in a string from the
 // task's memory.
-func CopyStringIn(cc marshal.CopyContext, addr usermem.Addr, dst *string) (int, error) {
+func CopyStringIn(cc marshal.CopyContext, addr hostarch.Addr, dst *string) (int, error) {
 	var buf ByteSlice
 	n, err := buf.CopyIn(cc, addr)
 	if err != nil {
@@ -320,12 +321,12 @@ func CopyStringIn(cc marshal.CopyContext, addr usermem.Addr, dst *string) (int,
 
 // CopyStringOut is a convenient wrapper for copying out a string to the task's
 // memory.
-func CopyStringOut(cc marshal.CopyContext, addr usermem.Addr, src string) (int, error) {
+func CopyStringOut(cc marshal.CopyContext, addr hostarch.Addr, src string) (int, error) {
 	srcP := ByteSlice(src)
 	return srcP.CopyOut(cc, addr)
 }
 
-// IOCopyContext wraps an object implementing usermem.IO to implement
+// IOCopyContext wraps an object implementing hostarch.IO to implement
 // marshal.CopyContext.
 type IOCopyContext struct {
 	Ctx  context.Context
@@ -339,11 +340,11 @@ func (i *IOCopyContext) CopyScratchBuffer(size int) []byte {
 }
 
 // CopyOutBytes implements marshal.CopyContext.CopyOutBytes.
-func (i *IOCopyContext) CopyOutBytes(addr usermem.Addr, b []byte) (int, error) {
+func (i *IOCopyContext) CopyOutBytes(addr hostarch.Addr, b []byte) (int, error) {
 	return i.IO.CopyOut(i.Ctx, addr, b, i.Opts)
 }
 
 // CopyInBytes implements marshal.CopyContext.CopyInBytes.
-func (i *IOCopyContext) CopyInBytes(addr usermem.Addr, b []byte) (int, error) {
+func (i *IOCopyContext) CopyInBytes(addr hostarch.Addr, b []byte) (int, error) {
 	return i.IO.CopyIn(i.Ctx, addr, b, i.Opts)
 }