1 files changed, 14 insertions, 13 deletions

diff --git a/pkg/sentry/kernel/task_futex.go b/pkg/sentry/kernel/task_futex.go
index 195c7da9b..4dc41b82b 100644
--- a/pkg/sentry/kernel/task_futex.go
+++ b/pkg/sentry/kernel/task_futex.go
@@ -16,6 +16,7 @@ package kernel
 
 import (
 	"gvisor.dev/gvisor/pkg/abi/linux"
+	"gvisor.dev/gvisor/pkg/hostarch"
 	"gvisor.dev/gvisor/pkg/marshal/primitive"
 	"gvisor.dev/gvisor/pkg/sentry/kernel/futex"
 	"gvisor.dev/gvisor/pkg/usermem"
@@ -30,33 +31,33 @@ func (t *Task) Futex() *futex.Manager {
 }
 
 // SwapUint32 implements futex.Target.SwapUint32.
-func (t *Task) SwapUint32(addr usermem.Addr, new uint32) (uint32, error) {
+func (t *Task) SwapUint32(addr hostarch.Addr, new uint32) (uint32, error) {
 	return t.MemoryManager().SwapUint32(t, addr, new, usermem.IOOpts{
 		AddressSpaceActive: true,
 	})
 }
 
 // CompareAndSwapUint32 implements futex.Target.CompareAndSwapUint32.
-func (t *Task) CompareAndSwapUint32(addr usermem.Addr, old, new uint32) (uint32, error) {
+func (t *Task) CompareAndSwapUint32(addr hostarch.Addr, old, new uint32) (uint32, error) {
 	return t.MemoryManager().CompareAndSwapUint32(t, addr, old, new, usermem.IOOpts{
 		AddressSpaceActive: true,
 	})
 }
 
 // LoadUint32 implements futex.Target.LoadUint32.
-func (t *Task) LoadUint32(addr usermem.Addr) (uint32, error) {
+func (t *Task) LoadUint32(addr hostarch.Addr) (uint32, error) {
 	return t.MemoryManager().LoadUint32(t, addr, usermem.IOOpts{
 		AddressSpaceActive: true,
 	})
 }
 
 // GetSharedKey implements futex.Target.GetSharedKey.
-func (t *Task) GetSharedKey(addr usermem.Addr) (futex.Key, error) {
+func (t *Task) GetSharedKey(addr hostarch.Addr) (futex.Key, error) {
 	return t.MemoryManager().GetSharedFutexKey(t, addr)
 }
 
 // GetRobustList sets the robust futex list for the task.
-func (t *Task) GetRobustList() usermem.Addr {
+func (t *Task) GetRobustList() hostarch.Addr {
 	t.mu.Lock()
 	addr := t.robustList
 	t.mu.Unlock()
@@ -64,7 +65,7 @@ func (t *Task) GetRobustList() usermem.Addr {
 }
 
 // SetRobustList sets the robust futex list for the task.
-func (t *Task) SetRobustList(addr usermem.Addr) {
+func (t *Task) SetRobustList(addr hostarch.Addr) {
 	t.mu.Lock()
 	t.robustList = addr
 	t.mu.Unlock()
@@ -84,28 +85,28 @@ func (t *Task) exitRobustList() {
 	}
 
 	var rl linux.RobustListHead
-	if _, err := rl.CopyIn(t, usermem.Addr(addr)); err != nil {
+	if _, err := rl.CopyIn(t, hostarch.Addr(addr)); err != nil {
 		return
 	}
 
 	next := primitive.Uint64(rl.List)
 	done := 0
-	var pendingLockAddr usermem.Addr
+	var pendingLockAddr hostarch.Addr
 	if rl.ListOpPending != 0 {
-		pendingLockAddr = usermem.Addr(rl.ListOpPending + rl.FutexOffset)
+		pendingLockAddr = hostarch.Addr(rl.ListOpPending + rl.FutexOffset)
 	}
 
 	// Wake up normal elements.
-	for usermem.Addr(next) != addr {
+	for hostarch.Addr(next) != addr {
 		// We traverse to the next element of the list before we
 		// actually wake anything. This prevents the race where waking
 		// this futex causes a modification of the list.
-		thisLockAddr := usermem.Addr(uint64(next) + rl.FutexOffset)
+		thisLockAddr := hostarch.Addr(uint64(next) + rl.FutexOffset)
 
 		// Try to decode the next element in the list before waking the
 		// current futex. But don't check the error until after we've
 		// woken the current futex. Linux does it in this order too
-		_, nextErr := next.CopyIn(t, usermem.Addr(next))
+		_, nextErr := next.CopyIn(t, hostarch.Addr(next))
 
 		// Wakeup the current futex if it's not pending.
 		if thisLockAddr != pendingLockAddr {
@@ -133,7 +134,7 @@ func (t *Task) exitRobustList() {
 }
 
 // wakeRobustListOne wakes a single futex from the robust list.
-func (t *Task) wakeRobustListOne(addr usermem.Addr) {
+func (t *Task) wakeRobustListOne(addr hostarch.Addr) {
 	// Bit 0 in address signals PI futex.
 	pi := addr&1 == 1
 	addr = addr &^ 1