[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

1 files changed, 86 insertions, 85 deletions

diff --git a/pkg/merkletree/merkletree_test.go b/pkg/merkletree/merkletree_test.go
index ed332b3f1..5d6f8df1b 100644
--- a/pkg/merkletree/merkletree_test.go
+++ b/pkg/merkletree/merkletree_test.go
@@ -24,7 +24,8 @@ import (
 	"time"
 
 	"gvisor.dev/gvisor/pkg/abi/linux"
-	"gvisor.dev/gvisor/pkg/usermem"
+
+	"gvisor.dev/gvisor/pkg/hostarch"
 )
 
 func TestLayout(t *testing.T) {
@@ -58,7 +59,7 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    32,
-			expectedLevelOffset:   []int64{usermem.PageSize},
+			expectedLevelOffset:   []int64{hostarch.PageSize},
 		},
 		{
 			name:                  "SmallSizeSHA512SameFile",
@@ -66,7 +67,7 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    64,
-			expectedLevelOffset:   []int64{usermem.PageSize},
+			expectedLevelOffset:   []int64{hostarch.PageSize},
 		},
 		{
 			name:                  "MiddleSizeSHA256SeparateFile",
@@ -74,7 +75,7 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: false,
 			expectedDigestSize:    32,
-			expectedLevelOffset:   []int64{0, 2 * usermem.PageSize, 3 * usermem.PageSize},
+			expectedLevelOffset:   []int64{0, 2 * hostarch.PageSize, 3 * hostarch.PageSize},
 		},
 		{
 			name:                  "MiddleSizeSHA512SeparateFile",
@@ -82,7 +83,7 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: false,
 			expectedDigestSize:    64,
-			expectedLevelOffset:   []int64{0, 4 * usermem.PageSize, 5 * usermem.PageSize},
+			expectedLevelOffset:   []int64{0, 4 * hostarch.PageSize, 5 * hostarch.PageSize},
 		},
 		{
 			name:                  "MiddleSizeSHA256SameFile",
@@ -90,7 +91,7 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    32,
-			expectedLevelOffset:   []int64{245 * usermem.PageSize, 247 * usermem.PageSize, 248 * usermem.PageSize},
+			expectedLevelOffset:   []int64{245 * hostarch.PageSize, 247 * hostarch.PageSize, 248 * hostarch.PageSize},
 		},
 		{
 			name:                  "MiddleSizeSHA512SameFile",
@@ -98,39 +99,39 @@ func TestLayout(t *testing.T) {
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    64,
-			expectedLevelOffset:   []int64{245 * usermem.PageSize, 249 * usermem.PageSize, 250 * usermem.PageSize},
+			expectedLevelOffset:   []int64{245 * hostarch.PageSize, 249 * hostarch.PageSize, 250 * hostarch.PageSize},
 		},
 		{
 			name:                  "LargeSizeSHA256SeparateFile",
-			dataSize:              4096 * int64(usermem.PageSize),
+			dataSize:              4096 * int64(hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: false,
 			expectedDigestSize:    32,
-			expectedLevelOffset:   []int64{0, 32 * usermem.PageSize, 33 * usermem.PageSize},
+			expectedLevelOffset:   []int64{0, 32 * hostarch.PageSize, 33 * hostarch.PageSize},
 		},
 		{
 			name:                  "LargeSizeSHA512SeparateFile",
-			dataSize:              4096 * int64(usermem.PageSize),
+			dataSize:              4096 * int64(hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: false,
 			expectedDigestSize:    64,
-			expectedLevelOffset:   []int64{0, 64 * usermem.PageSize, 65 * usermem.PageSize},
+			expectedLevelOffset:   []int64{0, 64 * hostarch.PageSize, 65 * hostarch.PageSize},
 		},
 		{
 			name:                  "LargeSizeSHA256SameFile",
-			dataSize:              4096 * int64(usermem.PageSize),
+			dataSize:              4096 * int64(hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    32,
-			expectedLevelOffset:   []int64{4096 * usermem.PageSize, 4128 * usermem.PageSize, 4129 * usermem.PageSize},
+			expectedLevelOffset:   []int64{4096 * hostarch.PageSize, 4128 * hostarch.PageSize, 4129 * hostarch.PageSize},
 		},
 		{
 			name:                  "LargeSizeSHA512SameFile",
-			dataSize:              4096 * int64(usermem.PageSize),
+			dataSize:              4096 * int64(hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedDigestSize:    64,
-			expectedLevelOffset:   []int64{4096 * usermem.PageSize, 4160 * usermem.PageSize, 4161 * usermem.PageSize},
+			expectedLevelOffset:   []int64{4096 * hostarch.PageSize, 4160 * hostarch.PageSize, 4161 * hostarch.PageSize},
 		},
 	}
 
@@ -140,8 +141,8 @@ func TestLayout(t *testing.T) {
 			if err != nil {
 				t.Fatalf("Failed to InitLayout: %v", err)
 			}
-			if l.blockSize != int64(usermem.PageSize) {
-				t.Errorf("Got blockSize %d, want %d", l.blockSize, usermem.PageSize)
+			if l.blockSize != int64(hostarch.PageSize) {
+				t.Errorf("Got blockSize %d, want %d", l.blockSize, hostarch.PageSize)
 			}
 			if l.digestSize != tc.expectedDigestSize {
 				t.Errorf("Got digestSize %d, want %d", l.digestSize, sha256DigestSize)
@@ -202,56 +203,56 @@ func TestGenerate(t *testing.T) {
 	}{
 		{
 			name:                  "OnePageZeroesSHA256SeparateFile",
-			data:                  bytes.Repeat([]byte{0}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{0}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{9, 115, 238, 230, 38, 140, 195, 70, 207, 144, 202, 118, 23, 113, 32, 129, 226, 239, 177, 69, 161, 26, 14, 113, 16, 37, 30, 96, 19, 148, 132, 27},
 		},
 		{
 			name:                  "OnePageZeroesSHA256SameFile",
-			data:                  bytes.Repeat([]byte{0}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{0}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{9, 115, 238, 230, 38, 140, 195, 70, 207, 144, 202, 118, 23, 113, 32, 129, 226, 239, 177, 69, 161, 26, 14, 113, 16, 37, 30, 96, 19, 148, 132, 27},
 		},
 		{
 			name:                  "OnePageZeroesSHA512SeparateFile",
-			data:                  bytes.Repeat([]byte{0}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{0}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{127, 8, 95, 11, 83, 101, 51, 39, 170, 235, 39, 43, 135, 243, 145, 118, 148, 58, 27, 155, 182, 205, 44, 47, 5, 223, 215, 17, 35, 16, 43, 104, 43, 11, 8, 88, 171, 7, 249, 243, 14, 62, 126, 218, 23, 159, 237, 237, 42, 226, 39, 25, 87, 48, 253, 191, 116, 213, 37, 3, 187, 152, 154, 14},
 		},
 		{
 			name:                  "OnePageZeroesSHA512SameFile",
-			data:                  bytes.Repeat([]byte{0}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{0}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{127, 8, 95, 11, 83, 101, 51, 39, 170, 235, 39, 43, 135, 243, 145, 118, 148, 58, 27, 155, 182, 205, 44, 47, 5, 223, 215, 17, 35, 16, 43, 104, 43, 11, 8, 88, 171, 7, 249, 243, 14, 62, 126, 218, 23, 159, 237, 237, 42, 226, 39, 25, 87, 48, 253, 191, 116, 213, 37, 3, 187, 152, 154, 14},
 		},
 		{
 			name:                  "MultiplePageZeroesSHA256SeparateFile",
-			data:                  bytes.Repeat([]byte{0}, 128*usermem.PageSize+1),
+			data:                  bytes.Repeat([]byte{0}, 128*hostarch.PageSize+1),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{247, 158, 42, 215, 180, 106, 0, 28, 77, 64, 132, 162, 74, 65, 250, 161, 243, 66, 129, 44, 197, 8, 145, 14, 94, 206, 156, 184, 145, 145, 20, 185},
 		},
 		{
 			name:                  "MultiplePageZeroesSHA256SameFile",
-			data:                  bytes.Repeat([]byte{0}, 128*usermem.PageSize+1),
+			data:                  bytes.Repeat([]byte{0}, 128*hostarch.PageSize+1),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{247, 158, 42, 215, 180, 106, 0, 28, 77, 64, 132, 162, 74, 65, 250, 161, 243, 66, 129, 44, 197, 8, 145, 14, 94, 206, 156, 184, 145, 145, 20, 185},
 		},
 		{
 			name:                  "MultiplePageZeroesSHA512SeparateFile",
-			data:                  bytes.Repeat([]byte{0}, 128*usermem.PageSize+1),
+			data:                  bytes.Repeat([]byte{0}, 128*hostarch.PageSize+1),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{100, 121, 14, 30, 104, 200, 142, 182, 190, 78, 23, 68, 157, 174, 23, 75, 174, 250, 250, 25, 66, 45, 235, 103, 129, 49, 78, 127, 173, 154, 121, 35, 37, 115, 60, 217, 26, 205, 253, 253, 236, 145, 107, 109, 232, 19, 72, 92, 4, 191, 181, 205, 191, 57, 234, 177, 144, 235, 143, 30, 15, 197, 109, 81},
 		},
 		{
 			name:                  "MultiplePageZeroesSHA512SameFile",
-			data:                  bytes.Repeat([]byte{0}, 128*usermem.PageSize+1),
+			data:                  bytes.Repeat([]byte{0}, 128*hostarch.PageSize+1),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{100, 121, 14, 30, 104, 200, 142, 182, 190, 78, 23, 68, 157, 174, 23, 75, 174, 250, 250, 25, 66, 45, 235, 103, 129, 49, 78, 127, 173, 154, 121, 35, 37, 115, 60, 217, 26, 205, 253, 253, 236, 145, 107, 109, 232, 19, 72, 92, 4, 191, 181, 205, 191, 57, 234, 177, 144, 235, 143, 30, 15, 197, 109, 81},
@@ -286,28 +287,28 @@ func TestGenerate(t *testing.T) {
 		},
 		{
 			name:                  "OnePageASHA256SeparateFile",
-			data:                  bytes.Repeat([]byte{'a'}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{'a'}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{132, 54, 112, 142, 156, 19, 50, 140, 138, 240, 192, 154, 100, 120, 242, 69, 64, 217, 62, 166, 127, 88, 23, 197, 100, 66, 255, 215, 214, 229, 54, 1},
 		},
 		{
 			name:                  "OnePageASHA256SameFile",
-			data:                  bytes.Repeat([]byte{'a'}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{'a'}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA256,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{132, 54, 112, 142, 156, 19, 50, 140, 138, 240, 192, 154, 100, 120, 242, 69, 64, 217, 62, 166, 127, 88, 23, 197, 100, 66, 255, 215, 214, 229, 54, 1},
 		},
 		{
 			name:                  "OnePageASHA512SeparateFile",
-			data:                  bytes.Repeat([]byte{'a'}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{'a'}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: false,
 			expectedHash:          []byte{165, 46, 176, 116, 47, 209, 101, 193, 64, 185, 30, 9, 52, 22, 24, 154, 135, 220, 232, 168, 215, 45, 222, 226, 207, 104, 160, 10, 156, 98, 245, 250, 76, 21, 68, 204, 65, 118, 69, 52, 210, 155, 36, 109, 233, 103, 1, 40, 218, 89, 125, 38, 247, 194, 2, 225, 119, 155, 65, 99, 182, 111, 110, 145},
 		},
 		{
 			name:                  "OnePageASHA512SameFile",
-			data:                  bytes.Repeat([]byte{'a'}, usermem.PageSize),
+			data:                  bytes.Repeat([]byte{'a'}, hostarch.PageSize),
 			hashAlgorithms:        linux.FS_VERITY_HASH_ALG_SHA512,
 			dataAndTreeInSameFile: true,
 			expectedHash:          []byte{165, 46, 176, 116, 47, 209, 101, 193, 64, 185, 30, 9, 52, 22, 24, 154, 135, 220, 232, 168, 215, 45, 222, 226, 207, 104, 160, 10, 156, 98, 245, 250, 76, 21, 68, 204, 65, 118, 69, 52, 210, 155, 36, 109, 233, 103, 1, 40, 218, 89, 125, 38, 247, 194, 2, 225, 119, 155, 65, 99, 182, 111, 110, 145},
@@ -415,14 +416,14 @@ func TestVerifyInvalidRange(t *testing.T) {
 		// Verify range starts outside data range.
 		{
 			name:        "StartOutsideRange",
-			verifyStart: usermem.PageSize,
+			verifyStart: hostarch.PageSize,
 			verifySize:  1,
 		},
 		// Verify range ends outside data range.
 		{
 			name:        "EndOutsideRange",
 			verifyStart: 0,
-			verifySize:  2 * usermem.PageSize,
+			verifySize:  2 * hostarch.PageSize,
 		},
 		// Verify range with negative size.
 		{
@@ -434,7 +435,7 @@ func TestVerifyInvalidRange(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, false /* dataAndTreeInSameFile */, false /* isSymlink */, tc.verifyStart, tc.verifySize, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, false /* dataAndTreeInSameFile */, false /* isSymlink */, tc.verifyStart, tc.verifySize, &buf)
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
 			}
@@ -467,7 +468,7 @@ func TestVerifyUnmodifiedMetadata(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, tc.isSymlink, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, tc.isSymlink, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			if tc.isSymlink {
 				params.SymlinkTarget = defaultSymlinkPath
 			}
@@ -495,7 +496,7 @@ func TestVerifyModifiedName(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.Name += "abc"
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -521,7 +522,7 @@ func TestVerifyModifiedSize(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.Size--
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -547,7 +548,7 @@ func TestVerifyModifiedMode(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.Mode++
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -573,7 +574,7 @@ func TestVerifyModifiedUID(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.UID++
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -599,7 +600,7 @@ func TestVerifyModifiedGID(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.GID++
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -625,7 +626,7 @@ func TestVerifyModifiedChildren(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			var buf bytes.Buffer
-			_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+			_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 			params.Children["abc"] = struct{}{}
 			if _, err := Verify(&params); errors.Is(err, nil) {
 				t.Errorf("Verification succeeded when expected to fail")
@@ -636,7 +637,7 @@ func TestVerifyModifiedChildren(t *testing.T) {
 
 func TestVerifyModifiedSymlink(t *testing.T) {
 	var buf bytes.Buffer
-	_, params := prepareVerify(t, usermem.PageSize /* dataSize */, defaultHashAlgorithm, false /* dataAndTreeInSameFile */, true /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
+	_, params := prepareVerify(t, hostarch.PageSize /* dataSize */, defaultHashAlgorithm, false /* dataAndTreeInSameFile */, true /* isSymlink */, 0 /* verifyStart */, 0 /* verifySize */, &buf)
 	params.SymlinkTarget = "merkle_modified_test_link"
 	if _, err := Verify(&params); err == nil {
 		t.Errorf("Verification succeeded when expected to fail")
@@ -652,30 +653,30 @@ func TestModifyOutsideVerifyRange(t *testing.T) {
 	}{
 		{
 			name:                  "BeforeRangeSeparateFile",
-			modifyByte:            4*usermem.PageSize - 1,
+			modifyByte:            4*hostarch.PageSize - 1,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "BeforeRangeSameFile",
-			modifyByte:            4*usermem.PageSize - 1,
+			modifyByte:            4*hostarch.PageSize - 1,
 			dataAndTreeInSameFile: true,
 		},
 		{
 			name:                  "AfterRangeSeparateFile",
-			modifyByte:            5 * usermem.PageSize,
+			modifyByte:            5 * hostarch.PageSize,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "AfterRangeSameFile",
-			modifyByte:            5 * usermem.PageSize,
+			modifyByte:            5 * hostarch.PageSize,
 			dataAndTreeInSameFile: true,
 		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			dataSize := int64(8 * usermem.PageSize)
-			verifyStart := int64(4 * usermem.PageSize)
-			verifySize := int64(usermem.PageSize)
+			dataSize := int64(8 * hostarch.PageSize)
+			verifyStart := int64(4 * hostarch.PageSize)
+			verifySize := int64(hostarch.PageSize)
 			var buf bytes.Buffer
 			// Modified byte is outside verify range. Verify should succeed.
 			data, params := prepareVerify(t, dataSize, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, verifyStart, verifySize, &buf)
@@ -712,16 +713,16 @@ func TestModifyInsideVerifyRange(t *testing.T) {
 		// to fail.
 		{
 			name:                  "BlockAlignedRangeSeparateFile",
-			verifyStart:           4 * usermem.PageSize,
-			verifySize:            usermem.PageSize,
-			modifyByte:            4 * usermem.PageSize,
+			verifyStart:           4 * hostarch.PageSize,
+			verifySize:            hostarch.PageSize,
+			modifyByte:            4 * hostarch.PageSize,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "BlockAlignedRangeSameFile",
-			verifyStart:           4 * usermem.PageSize,
-			verifySize:            usermem.PageSize,
-			modifyByte:            4 * usermem.PageSize,
+			verifyStart:           4 * hostarch.PageSize,
+			verifySize:            hostarch.PageSize,
+			modifyByte:            4 * hostarch.PageSize,
 			dataAndTreeInSameFile: true,
 		},
 		// The tests below use a non-block-aligned verify range.
@@ -729,48 +730,48 @@ func TestModifyInsideVerifyRange(t *testing.T) {
 		// verify to fail.
 		{
 			name:                  "ModifyStartSeparateFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            4*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            4*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "ModifyStartSameFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            4*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            4*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: true,
 		},
 		// Modifying a byte at the end of verify range should cause
 		// verify to fail.
 		{
 			name:                  "ModifyEndSeparateFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            6*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            6*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "ModifyEndSameFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            6*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            6*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: true,
 		},
 		// Modifying a byte in the middle verified block should cause
 		// verify to fail.
 		{
 			name:                  "ModifyMiddleSeparateFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            5*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            5*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "ModifyMiddleSameFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            5*usermem.PageSize + 123,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            5*hostarch.PageSize + 123,
 			dataAndTreeInSameFile: true,
 		},
 		// Modifying a byte in the first block in the verified range
@@ -778,16 +779,16 @@ func TestModifyInsideVerifyRange(t *testing.T) {
 		// out of verify range.
 		{
 			name:                  "ModifyFirstBlockSeparateFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            4*usermem.PageSize + 122,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            4*hostarch.PageSize + 122,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "ModifyFirstBlockSameFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            4*usermem.PageSize + 122,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            4*hostarch.PageSize + 122,
 			dataAndTreeInSameFile: true,
 		},
 		// Modifying a byte in the last block in the verified range
@@ -795,22 +796,22 @@ func TestModifyInsideVerifyRange(t *testing.T) {
 		// out of verify range.
 		{
 			name:                  "ModifyLastBlockSeparateFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            6*usermem.PageSize + 124,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            6*hostarch.PageSize + 124,
 			dataAndTreeInSameFile: false,
 		},
 		{
 			name:                  "ModifyLastBlockSameFile",
-			verifyStart:           4*usermem.PageSize + 123,
-			verifySize:            2 * usermem.PageSize,
-			modifyByte:            6*usermem.PageSize + 124,
+			verifyStart:           4*hostarch.PageSize + 123,
+			verifySize:            2 * hostarch.PageSize,
+			modifyByte:            6*hostarch.PageSize + 124,
 			dataAndTreeInSameFile: true,
 		},
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			dataSize := int64(8 * usermem.PageSize)
+			dataSize := int64(8 * hostarch.PageSize)
 			var buf bytes.Buffer
 			data, params := prepareVerify(t, dataSize, defaultHashAlgorithm, tc.dataAndTreeInSameFile, false /* isSymlink */, tc.verifyStart, tc.verifySize, &buf)
 			// Flip a bit in data and checks Verify results.
@@ -854,7 +855,7 @@ func TestVerifyRandom(t *testing.T) {
 			rand.Seed(time.Now().UnixNano())
 			// Use a random dataSize.  Minimum size 2 so that we can pick a random
 			// portion from it.
-			dataSize := rand.Int63n(200*usermem.PageSize) + 2
+			dataSize := rand.Int63n(200*hostarch.PageSize) + 2
 
 			// Pick a random portion of data.
 			start := rand.Int63n(dataSize - 1)