diff --git a/dm-bht-userspace.c b/dm-bht-userspace.c
index 8ded77f..677eab5 100644
--- a/dm-bht-userspace.c
+++ b/dm-bht-userspace.c
@@ -19,7 +19,7 @@
 /**
  * dm_bht_compute_hash: hashes a page of data
  */
-static int dm_bht_compute_hash(struct dm_bht *bht, struct page *pg, u8 *digest)
+static int dm_bht_compute_hash(struct dm_bht *bht, const u8 *buffer, u8 *digest)
 {
 	struct hash_desc *hash_desc = &bht->hash_desc[0];
 
@@ -28,7 +28,7 @@
 	  DMCRIT("failed to reinitialize crypto hash");
 		return -EINVAL;
 	}
-	if (crypto_hash_update(hash_desc, (const u8 *)pg, PAGE_SIZE)) {
+	if (crypto_hash_update(hash_desc, buffer, PAGE_SIZE)) {
 		DMCRIT("crypto_hash_update failed");
 		return -EINVAL;
 	}
@@ -94,10 +94,9 @@
 			if (count == 0)
 				count = bht->node_count;
 			for (j = 0; j < count; j++, child++) {
-				struct page *pg = virt_to_page(child->nodes);
 				u8 *digest = dm_bht_node(bht, entry, j);
 
-				r = dm_bht_compute_hash(bht, pg, digest);
+				r = dm_bht_compute_hash(bht, child->nodes, digest);
 				if (r) {
 					DMERR("Failed to update (d=%d,i=%u)",
 					      depth, i);
@@ -107,7 +106,7 @@
 		}
 	}
 	r = dm_bht_compute_hash(bht,
-				virt_to_page(bht->levels[0].entries->nodes),
+				bht->levels[0].entries->nodes,
 				bht->root_digest);
 	if (r)
 		DMERR("Failed to update root hash");
@@ -137,5 +136,5 @@
 	struct dm_bht_entry *entry = dm_bht_get_entry(bht, depth - 1, block);
 	u8 *node = dm_bht_get_node(bht, entry, depth, block);
 
-	return dm_bht_compute_hash(bht, virt_to_page(block_data), node);
+	return dm_bht_compute_hash(bht, block_data, node);
 }
diff --git a/dm-bht.c b/dm-bht.c
index 3c19f7f..d77a465 100644
--- a/dm-bht.c
+++ b/dm-bht.c
@@ -37,13 +37,11 @@
 #define nr_cpu_ids 1
 #define smp_processor_id(_x) 0
 
-static inline struct page *alloc_page(void)
+static inline void *alloc_page(void)
 {
-	struct page *memptr;
+	void *memptr;
 
-	if (posix_memalign((void **)&memptr,
-			   sizeof(struct page),
-			   sizeof(struct page)))
+	if (posix_memalign((void **)&memptr, PAGE_SIZE, PAGE_SIZE))
 	    return NULL;
 	return memptr;
 }
@@ -105,7 +103,7 @@
 /**
  * dm_bht_compute_hash: hashes a page of data
  */
-static int dm_bht_compute_hash(struct dm_bht *bht, struct page *pg, u8 *digest)
+static int dm_bht_compute_hash(struct dm_bht *bht, const u8 *buffer, u8 *digest)
 {
 	struct hash_desc *hash_desc = &bht->hash_desc[smp_processor_id()];
 
@@ -115,7 +113,7 @@
 			smp_processor_id());
 		return -EINVAL;
 	}
-	if (crypto_hash_update(hash_desc, (const u8 *)pg, PAGE_SIZE)) {
+	if (crypto_hash_update(hash_desc, buffer, PAGE_SIZE)) {
 		DMCRIT("crypto_hash_update failed");
 		return -EINVAL;
 	}
@@ -362,7 +360,7 @@
  * Verifies the path. Returns 0 on ok.
  */
 static int dm_bht_verify_path(struct dm_bht *bht, unsigned int block,
-			      struct page *pg)
+			      const u8 *buffer)
 {
 	int depth = bht->depth;
 	u8 digest[DM_BHT_MAX_DIGEST_SIZE];
@@ -382,18 +380,18 @@
 		BUG_ON(state < DM_BHT_ENTRY_READY);
 		node = dm_bht_get_node(bht, entry, depth, block);
 
-		if (dm_bht_compute_hash(bht, pg, digest) ||
+		if (dm_bht_compute_hash(bht, buffer, digest) ||
 		    memcmp(digest, node, bht->digest_size))
 			goto mismatch;
 
 		/* Keep the containing block of hashes to be verified in the
 		 * next pass.
 		 */
-		pg = virt_to_page(entry->nodes);
+		buffer = entry->nodes;
 	} while (--depth > 0 && state != DM_BHT_ENTRY_VERIFIED);
 
 	if (depth == 0 && state != DM_BHT_ENTRY_VERIFIED) {
-		if (dm_bht_compute_hash(bht, pg, digest) ||
+		if (dm_bht_compute_hash(bht, buffer, digest) ||
 		    memcmp(digest, bht->root_digest, bht->digest_size))
 			goto mismatch;
 		entry->state = DM_BHT_ENTRY_VERIFIED;
@@ -484,7 +482,7 @@
 		struct dm_bht_level *level;
 		struct dm_bht_entry *entry;
 		unsigned int index;
-		struct page *pg;
+		u8 *buffer;
 
 		entry = dm_bht_get_entry(bht, depth, block);
 		state = entry->state;
@@ -499,12 +497,12 @@
 			continue;
 
 		/* Current entry is claimed for allocation and loading */
-		pg = alloc_page();
-		if (!pg)
+		buffer = (u8 *)alloc_page();
+		if (!buffer)
 			goto nomem;
 
 		/* dm-bht guarantees page-aligned memory for callbacks. */
-		entry->nodes = page_address(pg);
+		entry->nodes = buffer;
 
 		/* TODO(wad) error check callback here too */
 
@@ -530,7 +528,7 @@
  * dm_bht_verify_block - checks that all nodes in the path for @block are valid
  * @bht:	pointer to a dm_bht_create()d bht
  * @block:	specific block data is expected from
- * @pg:		page holding the block data
+ * @buffer:	page holding the block data
  * @offset:	offset into the page
  *
  * Returns 0 on success, 1 on missing data, and a negative error
@@ -538,11 +536,11 @@
  * should return similarly.
  */
 int dm_bht_verify_block(struct dm_bht *bht, unsigned int block,
-			struct page *pg, unsigned int offset)
+			const u8 *buffer, unsigned int offset)
 {
 	BUG_ON(offset != 0);
 
-	return dm_bht_verify_path(bht, block, pg);
+	return dm_bht_verify_path(bht, block, buffer);
 }
 
 /**
@@ -572,7 +570,7 @@
 				continue;
 			default:
 				BUG_ON(!entry->nodes);
-				free(virt_to_page(entry->nodes));
+				free(entry->nodes);
 				break;
 			}
 		}
diff --git a/dm-bht.h b/dm-bht.h
index 0612e11..1e3fa16 100644
--- a/dm-bht.h
+++ b/dm-bht.h
@@ -35,9 +35,6 @@
 /* Additional possible return codes */
 #define DM_BHT_ENTRY_ERROR_MISMATCH -3 /* Digest mismatch */
 
-/* Forward declaration */
-struct page;
-
 /* dm_bht_entry
  * Contains dm_bht->node_count tree nodes at a given tree depth.
  * state is used to transactionally assure that data is paged in
@@ -134,7 +131,7 @@
 int dm_bht_populate(struct dm_bht *bht, void *read_cb_ctx,
 		    unsigned int block);
 int dm_bht_verify_block(struct dm_bht *bht, unsigned int block,
-			struct page *pg, unsigned int offset);
+			const u8 *buffer, unsigned int offset);
 int dm_bht_zeroread_callback(void *ctx, sector_t start, u8 *dst, sector_t count,
 			     struct dm_bht_entry *entry);
 void dm_bht_read_completed(struct dm_bht_entry *entry, int status);
diff --git a/dm-bht_unittest.cc b/dm-bht_unittest.cc
index bca905c..10b9c2e 100644
--- a/dm-bht_unittest.cc
+++ b/dm-bht_unittest.cc
@@ -180,8 +180,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -204,8 +203,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -228,8 +226,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -252,8 +249,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -276,8 +272,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -308,25 +303,18 @@
   EXPECT_EQ(dm_bht_store_block(bht_, kBadBlock, bad_hash_block), 0);
 
   // Attempt to verify both the bad block and all the neighbors.
-  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 1,
-                                virt_to_page(zero_page), 0), 0);
-
-  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 2,
-                                virt_to_page(zero_page), 0), 0);
-
+  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 1, zero_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + 2, zero_page, 0), 0);
   EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock + (bht_->node_count / 2),
-                                virt_to_page(zero_page), 0), 0);
-
-  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock,
-                                virt_to_page(zero_page), 0), 0);
+                                zero_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, kBadBlock, zero_page, 0), 0);
 
   // Verify that the prior entry is untouched and still safe
-  EXPECT_EQ(dm_bht_verify_block(bht_, kBadBlock - 1,
-                                virt_to_page(zero_page), 0), 0);
+  EXPECT_EQ(dm_bht_verify_block(bht_, kBadBlock - 1, zero_page, 0), 0);
 
   // Same for the next entry
   EXPECT_EQ(dm_bht_verify_block(bht_, kBadBlock + bht_->node_count,
-                                virt_to_page(zero_page), 0), 0);
+                                zero_page, 0), 0);
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
   free(bad_hash_block);
@@ -346,13 +334,12 @@
 
   memset(bad_page, 'A', PAGE_SIZE);
 
-
-  EXPECT_LT(dm_bht_verify_block(bht_, 0, virt_to_page(bad_page), 0), 0);
-  EXPECT_LT(dm_bht_verify_block(bht_, 127, virt_to_page(bad_page), 0), 0);
-  EXPECT_LT(dm_bht_verify_block(bht_, 128, virt_to_page(bad_page), 0), 0);
-  EXPECT_LT(dm_bht_verify_block(bht_, 255, virt_to_page(bad_page), 0), 0);
-  EXPECT_LT(dm_bht_verify_block(bht_, 256, virt_to_page(bad_page), 0), 0);
-  EXPECT_LT(dm_bht_verify_block(bht_, 383, virt_to_page(bad_page), 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 0, bad_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 127, bad_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 128, bad_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 255, bad_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 256, bad_page, 0), 0);
+  EXPECT_LT(dm_bht_verify_block(bht_, 383, bad_page, 0), 0);
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
   free(bad_page);
@@ -376,8 +363,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
@@ -402,8 +388,7 @@
 
   for (unsigned int blocks = 0; blocks < total_blocks; ++blocks) {
     DLOG(INFO) << "verifying block: " << blocks;
-    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks,
-                                     virt_to_page(zero_page), 0));
+    EXPECT_EQ(0, dm_bht_verify_block(bht_, blocks, zero_page, 0));
   }
 
   EXPECT_EQ(0, dm_bht_destroy(bht_));
diff --git a/include/asm/page.h b/include/asm/page.h
index fb18ab3..8883b33 100644
--- a/include/asm/page.h
+++ b/include/asm/page.h
@@ -8,17 +8,7 @@
 #ifndef VERITY_INCLUDE_ASM_PAGE_H_
 #define VERITY_INCLUDE_ASM_PAGE_H_
 
-#include <linux/types.h>
-
 #define PAGE_SIZE 4096
 #define PAGE_SHIFT 12
 
-/* A, uh, simple page dummy. */
-struct page {
-  u8 data[PAGE_SIZE];
-};
-
-#define page_address(p) ((p)->data)
-#define virt_to_page(x) ((struct page *)(x))
-
 #endif  /* VERITY_INCLUDE_ASM_PAGE_H_ */