[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

13 files changed, 115 insertions, 112 deletions

diff --git a/pkg/sentry/arch/BUILD b/pkg/sentry/arch/BUILD
index f660f1614..c9c52530d 100644
--- a/pkg/sentry/arch/BUILD
+++ b/pkg/sentry/arch/BUILD
@@ -32,6 +32,7 @@ go_library(
         "//pkg/abi/linux",
         "//pkg/context",
         "//pkg/cpuid",
+        "//pkg/hostarch",
         "//pkg/log",
         "//pkg/marshal",
         "//pkg/marshal/primitive",
diff --git a/pkg/sentry/arch/arch.go b/pkg/sentry/arch/arch.go
index 921151137..290863ee6 100644
--- a/pkg/sentry/arch/arch.go
+++ b/pkg/sentry/arch/arch.go
@@ -22,11 +22,11 @@ import (
 
 	"gvisor.dev/gvisor/pkg/abi/linux"
 	"gvisor.dev/gvisor/pkg/cpuid"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/marshal"
 	"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
 	"gvisor.dev/gvisor/pkg/sentry/limits"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // Arch describes an architecture.
@@ -188,11 +188,11 @@ type Context interface {
 	// returned layout must be no lower than min, and MaxAddr for the returned
 	// layout must be no higher than max. Repeated calls to NewMmapLayout may
 	// return different layouts.
-	NewMmapLayout(min, max usermem.Addr, limits *limits.LimitSet) (MmapLayout, error)
+	NewMmapLayout(min, max hostarch.Addr, limits *limits.LimitSet) (MmapLayout, error)
 
 	// PIELoadAddress returns a preferred load address for a
 	// position-independent executable within l.
-	PIELoadAddress(l MmapLayout) usermem.Addr
+	PIELoadAddress(l MmapLayout) hostarch.Addr
 
 	// FeatureSet returns the FeatureSet in use in this context.
 	FeatureSet() *cpuid.FeatureSet
@@ -257,18 +257,18 @@ const (
 // +stateify savable
 type MmapLayout struct {
 	// MinAddr is the lowest mappable address.
-	MinAddr usermem.Addr
+	MinAddr hostarch.Addr
 
 	// MaxAddr is the highest mappable address.
-	MaxAddr usermem.Addr
+	MaxAddr hostarch.Addr
 
 	// BottomUpBase is the lowest address that may be returned for a
 	// MmapBottomUp mmap.
-	BottomUpBase usermem.Addr
+	BottomUpBase hostarch.Addr
 
 	// TopDownBase is the highest address that may be returned for a
 	// MmapTopDown mmap.
-	TopDownBase usermem.Addr
+	TopDownBase hostarch.Addr
 
 	// DefaultDirection is the direction for most non-fixed mmaps in this
 	// layout.
@@ -316,9 +316,9 @@ type SyscallArgument struct {
 // SyscallArguments represents the set of arguments passed to a syscall.
 type SyscallArguments [6]SyscallArgument
 
-// Pointer returns the usermem.Addr representation of a pointer argument.
-func (a SyscallArgument) Pointer() usermem.Addr {
-	return usermem.Addr(a.Value)
+// Pointer returns the hostarch.Addr representation of a pointer argument.
+func (a SyscallArgument) Pointer() hostarch.Addr {
+	return hostarch.Addr(a.Value)
 }
 
 // Int returns the int32 representation of a 32-bit signed integer argument.
diff --git a/pkg/sentry/arch/arch_amd64.go b/pkg/sentry/arch/arch_amd64.go
index 2571be60f..d6b4d2357 100644
--- a/pkg/sentry/arch/arch_amd64.go
+++ b/pkg/sentry/arch/arch_amd64.go
@@ -23,11 +23,11 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/cpuid"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
 	"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
 	"gvisor.dev/gvisor/pkg/sentry/limits"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // Host specifies the host architecture.
@@ -37,7 +37,7 @@ const Host = AMD64
 const (
 	// maxAddr64 is the maximum userspace address. It is TASK_SIZE in Linux
 	// for a 64-bit process.
-	maxAddr64 usermem.Addr = (1 << 47) - usermem.PageSize
+	maxAddr64 hostarch.Addr = (1 << 47) - hostarch.PageSize
 
 	// maxStackRand64 is the maximum randomization to apply to the stack.
 	// It is defined by arch/x86/mm/mmap.c:stack_maxrandom_size in Linux.
@@ -45,7 +45,7 @@ const (
 
 	// maxMmapRand64 is the maximum randomization to apply to the mmap
 	// layout. It is defined by arch/x86/mm/mmap.c:arch_mmap_rnd in Linux.
-	maxMmapRand64 = (1 << 28) * usermem.PageSize
+	maxMmapRand64 = (1 << 28) * hostarch.PageSize
 
 	// minGap64 is the minimum gap to leave at the top of the address space
 	// for the stack. It is defined by arch/x86/mm/mmap.c:MIN_GAP in Linux.
@@ -56,7 +56,7 @@ const (
 	//
 	// The Platform {Min,Max}UserAddress() may preclude loading at this
 	// address. See other preferredFoo comments below.
-	preferredPIELoadAddr usermem.Addr = maxAddr64 / 3 * 2
+	preferredPIELoadAddr hostarch.Addr = maxAddr64 / 3 * 2
 )
 
 // These constants are selected as heuristics to help make the Platform's
@@ -92,13 +92,13 @@ const (
 	// This is all "preferred" because the layout min/max address may not
 	// allow us to select such a TopDownBase, in which case we have to fall
 	// back to a layout that TSAN may not be happy with.
-	preferredTopDownAllocMin usermem.Addr = 0x7e8000000000
-	preferredAllocationGap                = 128 << 30 // 128 GB
-	preferredTopDownBaseMin               = preferredTopDownAllocMin + preferredAllocationGap
+	preferredTopDownAllocMin hostarch.Addr = 0x7e8000000000
+	preferredAllocationGap                 = 128 << 30 // 128 GB
+	preferredTopDownBaseMin                = preferredTopDownAllocMin + preferredAllocationGap
 
 	// minMmapRand64 is the smallest we are willing to make the
 	// randomization to stay above preferredTopDownBaseMin.
-	minMmapRand64 = (1 << 26) * usermem.PageSize
+	minMmapRand64 = (1 << 26) * hostarch.PageSize
 )
 
 // context64 represents an AMD64 context.
@@ -207,12 +207,12 @@ func (c *context64) FeatureSet() *cpuid.FeatureSet {
 }
 
 // mmapRand returns a random adjustment for randomizing an mmap layout.
-func mmapRand(max uint64) usermem.Addr {
-	return usermem.Addr(rand.Int63n(int64(max))).RoundDown()
+func mmapRand(max uint64) hostarch.Addr {
+	return hostarch.Addr(rand.Int63n(int64(max))).RoundDown()
 }
 
 // NewMmapLayout implements Context.NewMmapLayout consistently with Linux.
-func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (MmapLayout, error) {
+func (c *context64) NewMmapLayout(min, max hostarch.Addr, r *limits.LimitSet) (MmapLayout, error) {
 	min, ok := min.RoundUp()
 	if !ok {
 		return MmapLayout{}, unix.EINVAL
@@ -230,7 +230,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 
 	// MAX_GAP in Linux.
 	maxGap := (max / 6) * 5
-	gap := usermem.Addr(stackSize.Cur)
+	gap := hostarch.Addr(stackSize.Cur)
 	if gap < minGap64 {
 		gap = minGap64
 	}
@@ -243,7 +243,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 	}
 
 	topDownMin := max - gap - maxMmapRand64
-	maxRand := usermem.Addr(maxMmapRand64)
+	maxRand := hostarch.Addr(maxMmapRand64)
 	if topDownMin < preferredTopDownBaseMin {
 		// Try to keep TopDownBase above preferredTopDownBaseMin by
 		// shrinking maxRand.
@@ -278,7 +278,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 }
 
 // PIELoadAddress implements Context.PIELoadAddress.
-func (c *context64) PIELoadAddress(l MmapLayout) usermem.Addr {
+func (c *context64) PIELoadAddress(l MmapLayout) hostarch.Addr {
 	base := preferredPIELoadAddr
 	max, ok := base.AddLength(maxMmapRand64)
 	if !ok {
@@ -311,7 +311,7 @@ func (c *context64) PtracePeekUser(addr uintptr) (marshal.Marshallable, error) {
 		regs := c.ptraceGetRegs()
 		buf := make([]byte, regs.SizeBytes())
 		regs.MarshalUnsafe(buf)
-		return c.Native(uintptr(usermem.ByteOrder.Uint64(buf[addr:]))), nil
+		return c.Native(uintptr(hostarch.ByteOrder.Uint64(buf[addr:]))), nil
 	}
 	// Note: x86 debug registers are missing.
 	return c.Native(0), nil
@@ -326,7 +326,7 @@ func (c *context64) PtracePokeUser(addr, data uintptr) error {
 		regs := c.ptraceGetRegs()
 		buf := make([]byte, regs.SizeBytes())
 		regs.MarshalUnsafe(buf)
-		usermem.ByteOrder.PutUint64(buf[addr:], uint64(data))
+		hostarch.ByteOrder.PutUint64(buf[addr:], uint64(data))
 		_, err := c.PtraceSetRegs(bytes.NewBuffer(buf))
 		return err
 	}
diff --git a/pkg/sentry/arch/arch_arm64.go b/pkg/sentry/arch/arch_arm64.go
index 14ad9483b..348f238fd 100644
--- a/pkg/sentry/arch/arch_arm64.go
+++ b/pkg/sentry/arch/arch_arm64.go
@@ -22,11 +22,11 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/cpuid"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
 	"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
 	"gvisor.dev/gvisor/pkg/sentry/limits"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // Host specifies the host architecture.
@@ -36,7 +36,7 @@ const Host = ARM64
 const (
 	// maxAddr64 is the maximum userspace address. It is TASK_SIZE in Linux
 	// for a 64-bit process.
-	maxAddr64 usermem.Addr = (1 << 48)
+	maxAddr64 hostarch.Addr = (1 << 48)
 
 	// maxStackRand64 is the maximum randomization to apply to the stack.
 	// It is defined by arch/arm64/mm/mmap.c:(STACK_RND_MASK << PAGE_SHIFT) in Linux.
@@ -44,7 +44,7 @@ const (
 
 	// maxMmapRand64 is the maximum randomization to apply to the mmap
 	// layout. It is defined by arch/arm64/mm/mmap.c:arch_mmap_rnd in Linux.
-	maxMmapRand64 = (1 << 33) * usermem.PageSize
+	maxMmapRand64 = (1 << 33) * hostarch.PageSize
 
 	// minGap64 is the minimum gap to leave at the top of the address space
 	// for the stack. It is defined by arch/arm64/mm/mmap.c:MIN_GAP in Linux.
@@ -55,7 +55,7 @@ const (
 	//
 	// The Platform {Min,Max}UserAddress() may preclude loading at this
 	// address. See other preferredFoo comments below.
-	preferredPIELoadAddr usermem.Addr = maxAddr64 / 6 * 5
+	preferredPIELoadAddr hostarch.Addr = maxAddr64 / 6 * 5
 )
 
 var (
@@ -66,13 +66,13 @@ var (
 // These constants are selected as heuristics to help make the Platform's
 // potentially limited address space conform as closely to Linux as possible.
 const (
-	preferredTopDownAllocMin usermem.Addr = 0x7e8000000000
-	preferredAllocationGap                = 128 << 30 // 128 GB
-	preferredTopDownBaseMin               = preferredTopDownAllocMin + preferredAllocationGap
+	preferredTopDownAllocMin hostarch.Addr = 0x7e8000000000
+	preferredAllocationGap                 = 128 << 30 // 128 GB
+	preferredTopDownBaseMin                = preferredTopDownAllocMin + preferredAllocationGap
 
 	// minMmapRand64 is the smallest we are willing to make the
 	// randomization to stay above preferredTopDownBaseMin.
-	minMmapRand64 = (1 << 18) * usermem.PageSize
+	minMmapRand64 = (1 << 18) * hostarch.PageSize
 )
 
 // context64 represents an ARM64 context.
@@ -187,12 +187,12 @@ func (c *context64) FeatureSet() *cpuid.FeatureSet {
 }
 
 // mmapRand returns a random adjustment for randomizing an mmap layout.
-func mmapRand(max uint64) usermem.Addr {
-	return usermem.Addr(rand.Int63n(int64(max))).RoundDown()
+func mmapRand(max uint64) hostarch.Addr {
+	return hostarch.Addr(rand.Int63n(int64(max))).RoundDown()
 }
 
 // NewMmapLayout implements Context.NewMmapLayout consistently with Linux.
-func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (MmapLayout, error) {
+func (c *context64) NewMmapLayout(min, max hostarch.Addr, r *limits.LimitSet) (MmapLayout, error) {
 	min, ok := min.RoundUp()
 	if !ok {
 		return MmapLayout{}, unix.EINVAL
@@ -210,7 +210,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 
 	// MAX_GAP in Linux.
 	maxGap := (max / 6) * 5
-	gap := usermem.Addr(stackSize.Cur)
+	gap := hostarch.Addr(stackSize.Cur)
 	if gap < minGap64 {
 		gap = minGap64
 	}
@@ -223,7 +223,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 	}
 
 	topDownMin := max - gap - maxMmapRand64
-	maxRand := usermem.Addr(maxMmapRand64)
+	maxRand := hostarch.Addr(maxMmapRand64)
 	if topDownMin < preferredTopDownBaseMin {
 		// Try to keep TopDownBase above preferredTopDownBaseMin by
 		// shrinking maxRand.
@@ -258,7 +258,7 @@ func (c *context64) NewMmapLayout(min, max usermem.Addr, r *limits.LimitSet) (Mm
 }
 
 // PIELoadAddress implements Context.PIELoadAddress.
-func (c *context64) PIELoadAddress(l MmapLayout) usermem.Addr {
+func (c *context64) PIELoadAddress(l MmapLayout) hostarch.Addr {
 	base := preferredPIELoadAddr
 	max, ok := base.AddLength(maxMmapRand64)
 	if !ok {
diff --git a/pkg/sentry/arch/auxv.go b/pkg/sentry/arch/auxv.go
index 2b4c8f3fc..19ca18121 100644
--- a/pkg/sentry/arch/auxv.go
+++ b/pkg/sentry/arch/auxv.go
@@ -15,7 +15,7 @@
 package arch
 
 import (
-	"gvisor.dev/gvisor/pkg/usermem"
+	"gvisor.dev/gvisor/pkg/hostarch"
 )
 
 // An AuxEntry represents an entry in an ELF auxiliary vector.
@@ -23,7 +23,7 @@ import (
 // +stateify savable
 type AuxEntry struct {
 	Key   uint64
-	Value usermem.Addr
+	Value hostarch.Addr
 }
 
 // An Auxv represents an ELF auxiliary vector.
diff --git a/pkg/sentry/arch/fpu/BUILD b/pkg/sentry/arch/fpu/BUILD
index 0a5395267..4e4f20639 100644
--- a/pkg/sentry/arch/fpu/BUILD
+++ b/pkg/sentry/arch/fpu/BUILD
@@ -13,9 +13,9 @@ go_library(
     visibility = ["//:sandbox"],
     deps = [
         "//pkg/cpuid",
+        "//pkg/hostarch",
         "//pkg/sync",
         "//pkg/syserror",
-        "//pkg/usermem",
         "@org_golang_x_sys//unix:go_default_library",
     ],
 )
diff --git a/pkg/sentry/arch/fpu/fpu_amd64.go b/pkg/sentry/arch/fpu/fpu_amd64.go
index 3a62f51be..1e9625bee 100644
--- a/pkg/sentry/arch/fpu/fpu_amd64.go
+++ b/pkg/sentry/arch/fpu/fpu_amd64.go
@@ -21,9 +21,9 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/cpuid"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/sync"
 	"gvisor.dev/gvisor/pkg/syserror"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // initX86FPState (defined in asm files) sets up initial state.
@@ -146,11 +146,11 @@ const (
 // any of the reserved bits of the MXCSR register." - Intel SDM Vol. 1, Section
 // 10.5.1.2 "SSE State")
 func sanitizeMXCSR(f State) {
-	mxcsr := usermem.ByteOrder.Uint32(f[mxcsrOffset:])
+	mxcsr := hostarch.ByteOrder.Uint32(f[mxcsrOffset:])
 	initMXCSRMask.Do(func() {
 		temp := State(alignedBytes(uint(ptraceFPRegsSize), 16))
 		initX86FPState(&temp[0], false /* useXsave */)
-		mxcsrMask = usermem.ByteOrder.Uint32(temp[mxcsrMaskOffset:])
+		mxcsrMask = hostarch.ByteOrder.Uint32(temp[mxcsrMaskOffset:])
 		if mxcsrMask == 0 {
 			// "If the value of the MXCSR_MASK field is 00000000H, then the
 			// MXCSR_MASK value is the default value of 0000FFBFH." - Intel SDM
@@ -160,7 +160,7 @@ func sanitizeMXCSR(f State) {
 		}
 	})
 	mxcsr &= mxcsrMask
-	usermem.ByteOrder.PutUint32(f[mxcsrOffset:], mxcsr)
+	hostarch.ByteOrder.PutUint32(f[mxcsrOffset:], mxcsr)
 }
 
 // PtraceGetXstateRegs implements ptrace(PTRACE_GETREGS, NT_X86_XSTATE) by
@@ -177,7 +177,7 @@ func (s *State) PtraceGetXstateRegs(dst io.Writer, maxlen int, featureSet *cpuid
 	// Area". Linux uses the first 8 bytes of this area to store the OS XSTATE
 	// mask. GDB relies on this: see
 	// gdb/x86-linux-nat.c:x86_linux_read_description().
-	usermem.ByteOrder.PutUint64(f[userXstateXCR0Offset:], featureSet.ValidXCR0Mask())
+	hostarch.ByteOrder.PutUint64(f[userXstateXCR0Offset:], featureSet.ValidXCR0Mask())
 	if len(f) > maxlen {
 		f = f[:maxlen]
 	}
@@ -208,9 +208,9 @@ func (s *State) PtraceSetXstateRegs(src io.Reader, maxlen int, featureSet *cpuid
 	// Force reserved bits in MXCSR to 0. This is consistent with Linux.
 	sanitizeMXCSR(State(f))
 	// Users can't enable *more* XCR0 bits than what we, and the CPU, support.
-	xstateBV := usermem.ByteOrder.Uint64(f[xstateBVOffset:])
+	xstateBV := hostarch.ByteOrder.Uint64(f[xstateBVOffset:])
 	xstateBV &= featureSet.ValidXCR0Mask()
-	usermem.ByteOrder.PutUint64(f[xstateBVOffset:], xstateBV)
+	hostarch.ByteOrder.PutUint64(f[xstateBVOffset:], xstateBV)
 	// Force XCOMP_BV and reserved bytes in the XSAVE header to 0.
 	reserved := f[xsaveHeaderZeroedOffset : xsaveHeaderZeroedOffset+xsaveHeaderZeroedBytes]
 	for i := range reserved {
@@ -266,7 +266,7 @@ func (s *State) AfterLoad() {
 		// What was in use?
 		savedBV := fxsaveBV
 		if len(old) >= xstateBVOffset+8 {
-			savedBV = usermem.ByteOrder.Uint64(old[xstateBVOffset:])
+			savedBV = hostarch.ByteOrder.Uint64(old[xstateBVOffset:])
 		}
 
 		// Supported features must be a superset of saved features.
diff --git a/pkg/sentry/arch/signal.go b/pkg/sentry/arch/signal.go
index 35d2e07c3..67d7edf68 100644
--- a/pkg/sentry/arch/signal.go
+++ b/pkg/sentry/arch/signal.go
@@ -16,7 +16,7 @@ package arch
 
 import (
 	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/usermem"
+	"gvisor.dev/gvisor/pkg/hostarch"
 )
 
 // SignalAct represents the action that should be taken when a signal is
@@ -154,107 +154,107 @@ func (s *SignalInfo) FixSignalCodeForUser() {
 
 // PID returns the si_pid field.
 func (s *SignalInfo) PID() int32 {
-	return int32(usermem.ByteOrder.Uint32(s.Fields[0:4]))
+	return int32(hostarch.ByteOrder.Uint32(s.Fields[0:4]))
 }
 
 // SetPID mutates the si_pid field.
 func (s *SignalInfo) SetPID(val int32) {
-	usermem.ByteOrder.PutUint32(s.Fields[0:4], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[0:4], uint32(val))
 }
 
 // UID returns the si_uid field.
 func (s *SignalInfo) UID() int32 {
-	return int32(usermem.ByteOrder.Uint32(s.Fields[4:8]))
+	return int32(hostarch.ByteOrder.Uint32(s.Fields[4:8]))
 }
 
 // SetUID mutates the si_uid field.
 func (s *SignalInfo) SetUID(val int32) {
-	usermem.ByteOrder.PutUint32(s.Fields[4:8], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[4:8], uint32(val))
 }
 
 // Sigval returns the sigval field, which is aliased to both si_int and si_ptr.
 func (s *SignalInfo) Sigval() uint64 {
-	return usermem.ByteOrder.Uint64(s.Fields[8:16])
+	return hostarch.ByteOrder.Uint64(s.Fields[8:16])
 }
 
 // SetSigval mutates the sigval field.
 func (s *SignalInfo) SetSigval(val uint64) {
-	usermem.ByteOrder.PutUint64(s.Fields[8:16], val)
+	hostarch.ByteOrder.PutUint64(s.Fields[8:16], val)
 }
 
 // TimerID returns the si_timerid field.
 func (s *SignalInfo) TimerID() linux.TimerID {
-	return linux.TimerID(usermem.ByteOrder.Uint32(s.Fields[0:4]))
+	return linux.TimerID(hostarch.ByteOrder.Uint32(s.Fields[0:4]))
 }
 
 // SetTimerID sets the si_timerid field.
 func (s *SignalInfo) SetTimerID(val linux.TimerID) {
-	usermem.ByteOrder.PutUint32(s.Fields[0:4], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[0:4], uint32(val))
 }
 
 // Overrun returns the si_overrun field.
 func (s *SignalInfo) Overrun() int32 {
-	return int32(usermem.ByteOrder.Uint32(s.Fields[4:8]))
+	return int32(hostarch.ByteOrder.Uint32(s.Fields[4:8]))
 }
 
 // SetOverrun sets the si_overrun field.
 func (s *SignalInfo) SetOverrun(val int32) {
-	usermem.ByteOrder.PutUint32(s.Fields[4:8], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[4:8], uint32(val))
 }
 
 // Addr returns the si_addr field.
 func (s *SignalInfo) Addr() uint64 {
-	return usermem.ByteOrder.Uint64(s.Fields[0:8])
+	return hostarch.ByteOrder.Uint64(s.Fields[0:8])
 }
 
 // SetAddr sets the si_addr field.
 func (s *SignalInfo) SetAddr(val uint64) {
-	usermem.ByteOrder.PutUint64(s.Fields[0:8], val)
+	hostarch.ByteOrder.PutUint64(s.Fields[0:8], val)
 }
 
 // Status returns the si_status field.
 func (s *SignalInfo) Status() int32 {
-	return int32(usermem.ByteOrder.Uint32(s.Fields[8:12]))
+	return int32(hostarch.ByteOrder.Uint32(s.Fields[8:12]))
 }
 
 // SetStatus mutates the si_status field.
 func (s *SignalInfo) SetStatus(val int32) {
-	usermem.ByteOrder.PutUint32(s.Fields[8:12], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[8:12], uint32(val))
 }
 
 // CallAddr returns the si_call_addr field.
 func (s *SignalInfo) CallAddr() uint64 {
-	return usermem.ByteOrder.Uint64(s.Fields[0:8])
+	return hostarch.ByteOrder.Uint64(s.Fields[0:8])
 }
 
 // SetCallAddr mutates the si_call_addr field.
 func (s *SignalInfo) SetCallAddr(val uint64) {
-	usermem.ByteOrder.PutUint64(s.Fields[0:8], val)
+	hostarch.ByteOrder.PutUint64(s.Fields[0:8], val)
 }
 
 // Syscall returns the si_syscall field.
 func (s *SignalInfo) Syscall() int32 {
-	return int32(usermem.ByteOrder.Uint32(s.Fields[8:12]))
+	return int32(hostarch.ByteOrder.Uint32(s.Fields[8:12]))
 }
 
 // SetSyscall mutates the si_syscall field.
 func (s *SignalInfo) SetSyscall(val int32) {
-	usermem.ByteOrder.PutUint32(s.Fields[8:12], uint32(val))
+	hostarch.ByteOrder.PutUint32(s.Fields[8:12], uint32(val))
 }
 
 // Arch returns the si_arch field.
 func (s *SignalInfo) Arch() uint32 {
-	return usermem.ByteOrder.Uint32(s.Fields[12:16])
+	return hostarch.ByteOrder.Uint32(s.Fields[12:16])
 }
 
 // SetArch mutates the si_arch field.
 func (s *SignalInfo) SetArch(val uint32) {
-	usermem.ByteOrder.PutUint32(s.Fields[12:16], val)
+	hostarch.ByteOrder.PutUint32(s.Fields[12:16], val)
 }
 
 // Band returns the si_band field.
 func (s *SignalInfo) Band() int64 {
-	return int64(usermem.ByteOrder.Uint64(s.Fields[0:8]))
+	return int64(hostarch.ByteOrder.Uint64(s.Fields[0:8]))
 }
 
 // SetBand mutates the si_band field.
@@ -262,15 +262,15 @@ func (s *SignalInfo) SetBand(val int64) {
 	// Note: this assumes the platform uses `long` as `__ARCH_SI_BAND_T`.
 	// On some platforms, which gVisor doesn't support, `__ARCH_SI_BAND_T` is
 	// `int`. See siginfo.h.
-	usermem.ByteOrder.PutUint64(s.Fields[0:8], uint64(val))
+	hostarch.ByteOrder.PutUint64(s.Fields[0:8], uint64(val))
 }
 
 // FD returns the si_fd field.
 func (s *SignalInfo) FD() uint32 {
-	return usermem.ByteOrder.Uint32(s.Fields[8:12])
+	return hostarch.ByteOrder.Uint32(s.Fields[8:12])
 }
 
 // SetFD mutates the si_fd field.
 func (s *SignalInfo) SetFD(val uint32) {
-	usermem.ByteOrder.PutUint32(s.Fields[8:12], val)
+	hostarch.ByteOrder.PutUint32(s.Fields[8:12], val)
 }
diff --git a/pkg/sentry/arch/signal_amd64.go b/pkg/sentry/arch/signal_amd64.go
index ee3743483..082ed92b1 100644
--- a/pkg/sentry/arch/signal_amd64.go
+++ b/pkg/sentry/arch/signal_amd64.go
@@ -21,10 +21,10 @@ import (
 
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/abi/linux"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
 	"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // SignalContext64 is equivalent to struct sigcontext, the type passed as the
@@ -133,7 +133,7 @@ func (c *context64) SignalSetup(st *Stack, act *SignalAct, info *SignalInfo, alt
 	// space on the user stack naturally caps the amount of memory the
 	// sentry will allocate for this purpose.
 	fpSize, _ := c.fpuFrameSize()
-	sp = (sp - usermem.Addr(fpSize)) & ^usermem.Addr(63)
+	sp = (sp - hostarch.Addr(fpSize)) & ^hostarch.Addr(63)
 
 	// Construct the UContext64 now since we need its size.
 	uc := &UContext64{
@@ -180,8 +180,8 @@ func (c *context64) SignalSetup(st *Stack, act *SignalAct, info *SignalInfo, alt
 	ucSize := uc.SizeBytes()
 	// st.Arch.Width() is for the restorer address. sizeof(siginfo) == 128.
 	frameSize := int(st.Arch.Width()) + ucSize + 128
-	frameBottom := (sp-usermem.Addr(frameSize)) & ^usermem.Addr(15) - 8
-	sp = frameBottom + usermem.Addr(frameSize)
+	frameBottom := (sp-hostarch.Addr(frameSize)) & ^hostarch.Addr(15) - 8
+	sp = frameBottom + hostarch.Addr(frameSize)
 	st.Bottom = sp
 
 	// Prior to proceeding, figure out if the frame will exhaust the range
diff --git a/pkg/sentry/arch/signal_arm64.go b/pkg/sentry/arch/signal_arm64.go
index 53281dcba..da71fb873 100644
--- a/pkg/sentry/arch/signal_arm64.go
+++ b/pkg/sentry/arch/signal_arm64.go
@@ -19,9 +19,9 @@ package arch
 import (
 	"golang.org/x/sys/unix"
 	"gvisor.dev/gvisor/pkg/abi/linux"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/log"
 	"gvisor.dev/gvisor/pkg/sentry/arch/fpu"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // SignalContext64 is equivalent to struct sigcontext, the type passed as the
@@ -107,8 +107,8 @@ func (c *context64) SignalSetup(st *Stack, act *SignalAct, info *SignalInfo, alt
 	// sizeof(siginfo) == 128.
 	// R30 stores the restorer address.
 	frameSize := ucSize + 128
-	frameBottom := (sp - usermem.Addr(frameSize)) & ^usermem.Addr(15)
-	sp = frameBottom + usermem.Addr(frameSize)
+	frameBottom := (sp - hostarch.Addr(frameSize)) & ^hostarch.Addr(15)
+	sp = frameBottom + hostarch.Addr(frameSize)
 	st.Bottom = sp
 
 	// Prior to proceeding, figure out if the frame will exhaust the range
diff --git a/pkg/sentry/arch/signal_stack.go b/pkg/sentry/arch/signal_stack.go
index a1eae98f9..c732c7503 100644
--- a/pkg/sentry/arch/signal_stack.go
+++ b/pkg/sentry/arch/signal_stack.go
@@ -17,8 +17,8 @@
 package arch
 
 import (
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 const (
@@ -36,8 +36,8 @@ func (s SignalStack) IsEnabled() bool {
 }
 
 // Top returns the stack's top address.
-func (s SignalStack) Top() usermem.Addr {
-	return usermem.Addr(s.Addr + s.Size)
+func (s SignalStack) Top() hostarch.Addr {
+	return hostarch.Addr(s.Addr + s.Size)
 }
 
 // SetOnStack marks this signal stack as in use.
@@ -49,8 +49,8 @@ func (s *SignalStack) SetOnStack() {
 }
 
 // Contains checks if the stack pointer is within this stack.
-func (s *SignalStack) Contains(sp usermem.Addr) bool {
-	return usermem.Addr(s.Addr) < sp && sp <= usermem.Addr(s.Addr+s.Size)
+func (s *SignalStack) Contains(sp hostarch.Addr) bool {
+	return hostarch.Addr(s.Addr) < sp && sp <= hostarch.Addr(s.Addr+s.Size)
 }
 
 // NativeSignalStack is a type that is equivalent to stack_t in the guest
diff --git a/pkg/sentry/arch/stack.go b/pkg/sentry/arch/stack.go
index 5f06c751d..65a794c7c 100644
--- a/pkg/sentry/arch/stack.go
+++ b/pkg/sentry/arch/stack.go
@@ -16,18 +16,20 @@ package arch
 
 import (
 	"gvisor.dev/gvisor/pkg/context"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
+
 	"gvisor.dev/gvisor/pkg/usermem"
 )
 
-// Stack is a simple wrapper around a usermem.IO and an address. Stack
+// Stack is a simple wrapper around a hostarch.IO and an address. Stack
 // implements marshal.CopyContext, and marshallable values can be pushed or
 // popped from the stack through the marshal.Marshallable interface.
 //
 // Stack is not thread-safe.
 type Stack struct {
 	// Our arch info.
-	// We use this for automatic Native conversion of usermem.Addrs during
+	// We use this for automatic Native conversion of hostarch.Addrs during
 	// Push() and Pop().
 	Arch Context
 
@@ -35,7 +37,7 @@ type Stack struct {
 	IO usermem.IO
 
 	// Our current stack bottom.
-	Bottom usermem.Addr
+	Bottom hostarch.Addr
 
 	// Scratch buffer used for marshalling to avoid having to repeatedly
 	// allocate scratch memory.
@@ -59,20 +61,20 @@ func (s *Stack) CopyScratchBuffer(size int) []byte {
 // StackBottomMagic is the special address callers must past to all stack
 // marshalling operations to cause the src/dst address to be computed based on
 // the current end of the stack.
-const StackBottomMagic = ^usermem.Addr(0) // usermem.Addr(-1)
+const StackBottomMagic = ^hostarch.Addr(0) // hostarch.Addr(-1)
 
 // CopyOutBytes implements marshal.CopyContext.CopyOutBytes. CopyOutBytes
 // computes an appropriate address based on the current end of the
 // stack. Callers use the sentinel address StackBottomMagic to marshal methods
 // to indicate this.
-func (s *Stack) CopyOutBytes(sentinel usermem.Addr, b []byte) (int, error) {
+func (s *Stack) CopyOutBytes(sentinel hostarch.Addr, b []byte) (int, error) {
 	if sentinel != StackBottomMagic {
 		panic("Attempted to copy out to stack with absolute address")
 	}
 	c := len(b)
-	n, err := s.IO.CopyOut(context.Background(), s.Bottom-usermem.Addr(c), b, usermem.IOOpts{})
+	n, err := s.IO.CopyOut(context.Background(), s.Bottom-hostarch.Addr(c), b, usermem.IOOpts{})
 	if err == nil && n == c {
-		s.Bottom -= usermem.Addr(n)
+		s.Bottom -= hostarch.Addr(n)
 	}
 	return n, err
 }
@@ -81,21 +83,21 @@ func (s *Stack) CopyOutBytes(sentinel usermem.Addr, b []byte) (int, error) {
 // an appropriate address based on the current end of the stack. Callers must
 // use the sentinel address StackBottomMagic to marshal methods to indicate
 // this.
-func (s *Stack) CopyInBytes(sentinel usermem.Addr, b []byte) (int, error) {
+func (s *Stack) CopyInBytes(sentinel hostarch.Addr, b []byte) (int, error) {
 	if sentinel != StackBottomMagic {
 		panic("Attempted to copy in from stack with absolute address")
 	}
 	n, err := s.IO.CopyIn(context.Background(), s.Bottom, b, usermem.IOOpts{})
 	if err == nil {
-		s.Bottom += usermem.Addr(n)
+		s.Bottom += hostarch.Addr(n)
 	}
 	return n, err
 }
 
 // Align aligns the stack to the given offset.
 func (s *Stack) Align(offset int) {
-	if s.Bottom%usermem.Addr(offset) != 0 {
-		s.Bottom -= (s.Bottom % usermem.Addr(offset))
+	if s.Bottom%hostarch.Addr(offset) != 0 {
+		s.Bottom -= (s.Bottom % hostarch.Addr(offset))
 	}
 }
 
@@ -119,16 +121,16 @@ func (s *Stack) PushNullTerminatedByteSlice(bs []byte) (int, error) {
 // stack.
 type StackLayout struct {
 	// ArgvStart is the beginning of the argument vector.
-	ArgvStart usermem.Addr
+	ArgvStart hostarch.Addr
 
 	// ArgvEnd is the end of the argument vector.
-	ArgvEnd usermem.Addr
+	ArgvEnd hostarch.Addr
 
 	// EnvvStart is the beginning of the environment vector.
-	EnvvStart usermem.Addr
+	EnvvStart hostarch.Addr
 
 	// EnvvEnd is the end of the environment vector.
-	EnvvEnd usermem.Addr
+	EnvvEnd hostarch.Addr
 }
 
 // Load pushes the given args, env and aux vector to the stack using the
@@ -148,7 +150,7 @@ func (s *Stack) Load(args []string, env []string, aux Auxv) (StackLayout, error)
 	// to be in this order. See: https://www.uclibc.org/docs/psABI-x86_64.pdf
 	// page 29.
 	l.EnvvEnd = s.Bottom
-	envAddrs := make([]usermem.Addr, len(env))
+	envAddrs := make([]hostarch.Addr, len(env))
 	for i := len(env) - 1; i >= 0; i-- {
 		if _, err := s.PushNullTerminatedByteSlice([]byte(env[i])); err != nil {
 			return StackLayout{}, err
@@ -159,7 +161,7 @@ func (s *Stack) Load(args []string, env []string, aux Auxv) (StackLayout, error)
 
 	// Push our strings.
 	l.ArgvEnd = s.Bottom
-	argAddrs := make([]usermem.Addr, len(args))
+	argAddrs := make([]hostarch.Addr, len(args))
 	for i := len(args) - 1; i >= 0; i-- {
 		if _, err := s.PushNullTerminatedByteSlice([]byte(args[i])); err != nil {
 			return StackLayout{}, err
@@ -178,7 +180,7 @@ func (s *Stack) Load(args []string, env []string, aux Auxv) (StackLayout, error)
 	argvSize := s.Arch.Width() * uint(len(args)+1)
 	envvSize := s.Arch.Width() * uint(len(env)+1)
 	auxvSize := s.Arch.Width() * 2 * uint(len(aux)+1)
-	total := usermem.Addr(argvSize) + usermem.Addr(envvSize) + usermem.Addr(auxvSize) + usermem.Addr(s.Arch.Width())
+	total := hostarch.Addr(argvSize) + hostarch.Addr(envvSize) + hostarch.Addr(auxvSize) + hostarch.Addr(s.Arch.Width())
 	expectedBottom := s.Bottom - total
 	if expectedBottom%32 != 0 {
 		s.Bottom -= expectedBottom % 32
@@ -188,11 +190,11 @@ func (s *Stack) Load(args []string, env []string, aux Auxv) (StackLayout, error)
 	// NOTE: We need an extra zero here per spec.
 	// The Push function will automatically terminate
 	// strings and arrays with a single null value.
-	auxv := make([]usermem.Addr, 0, len(aux))
+	auxv := make([]hostarch.Addr, 0, len(aux))
 	for _, a := range aux {
-		auxv = append(auxv, usermem.Addr(a.Key), a.Value)
+		auxv = append(auxv, hostarch.Addr(a.Key), a.Value)
 	}
-	auxv = append(auxv, usermem.Addr(0))
+	auxv = append(auxv, hostarch.Addr(0))
 	_, err := s.pushAddrSliceAndTerminator(auxv)
 	if err != nil {
 		return StackLayout{}, err
diff --git a/pkg/sentry/arch/stack_unsafe.go b/pkg/sentry/arch/stack_unsafe.go
index 0e478e434..f4712d58f 100644
--- a/pkg/sentry/arch/stack_unsafe.go
+++ b/pkg/sentry/arch/stack_unsafe.go
@@ -17,19 +17,19 @@ package arch
 import (
 	"unsafe"
 
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
-	"gvisor.dev/gvisor/pkg/usermem"
 )
 
 // pushAddrSliceAndTerminator copies a slices of addresses to the stack, and
 // also pushes an extra null address element at the end of the slice.
 //
 // Internally, we unsafely transmute the slice type from the arch-dependent
-// []usermem.Addr type, to a slice of fixed-sized ints so that we can pass it to
+// []hostarch.Addr type, to a slice of fixed-sized ints so that we can pass it to
 // go-marshal.
 //
 // On error, the contents of the stack and the bottom cursor are undefined.
-func (s *Stack) pushAddrSliceAndTerminator(src []usermem.Addr) (int, error) {
+func (s *Stack) pushAddrSliceAndTerminator(src []hostarch.Addr) (int, error) {
 	// Note: Stack grows upwards, so push the terminator first.
 	switch s.Arch.Width() {
 	case 8: