diff --git a/kmod/src/block.c b/kmod/src/block.c
index 8c8f1b5b..b7da3950 100644
--- a/kmod/src/block.c
+++ b/kmod/src/block.c
@@ -108,18 +108,18 @@ do {									\
  * be refactored away.
  */
 
-__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr)
+__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr, u32 size)
 {
 	int off = offsetof(struct scoutfs_block_header, crc) +
 		  FIELD_SIZEOF(struct scoutfs_block_header, crc);
-	u32 calc = crc32c(~0, (char *)hdr + off, SCOUTFS_BLOCK_SIZE - off);
+	u32 calc = crc32c(~0, (char *)hdr + off, size - off);
 
 	return cpu_to_le32(calc);
 }
 
-bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr)
+bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr, u32 size)
 {
-	return hdr->crc == scoutfs_block_calc_crc(hdr);
+	return hdr->crc == scoutfs_block_calc_crc(hdr, size);
 }
 
 bool scoutfs_block_valid_ref(struct super_block *sb,
@@ -157,19 +157,19 @@ static struct block_private *block_alloc(struct super_block *sb, u64 blkno)
 	 * more careful with a partial page allocator when allocating
 	 * blocks and would make the lru per-page instead of per-block.
 	 */
-	BUILD_BUG_ON(PAGE_SIZE > SCOUTFS_BLOCK_SIZE);
+	BUILD_BUG_ON(PAGE_SIZE > SCOUTFS_BLOCK_LG_SIZE);
 
 	bp = kzalloc(sizeof(struct block_private), GFP_NOFS);
 	if (!bp)
 		goto out;
 
-	bp->page = alloc_pages(GFP_NOFS, SCOUTFS_BLOCK_PAGE_ORDER);
+	bp->page = alloc_pages(GFP_NOFS, SCOUTFS_BLOCK_LG_PAGE_ORDER);
 	if (bp->page) {
 		scoutfs_inc_counter(sb, block_cache_alloc_page_order);
 		set_bit(BLOCK_BIT_PAGE_ALLOC, &bp->bits);
 		bp->bl.data = page_address(bp->page);
 	} else {
-		bp->virt = __vmalloc(SCOUTFS_BLOCK_SIZE,
+		bp->virt = __vmalloc(SCOUTFS_BLOCK_LG_SIZE,
 				     GFP_NOFS | __GFP_HIGHMEM, PAGE_KERNEL);
 		if (!bp->virt) {
 			kfree(bp);
@@ -206,7 +206,7 @@ static void block_free(struct super_block *sb, struct block_private *bp)
 	TRACE_BLOCK(free, bp);
 
 	if (test_bit(BLOCK_BIT_PAGE_ALLOC, &bp->bits))
-		__free_pages(bp->page, SCOUTFS_BLOCK_PAGE_ORDER);
+		__free_pages(bp->page, SCOUTFS_BLOCK_LG_PAGE_ORDER);
 	else if (test_bit(BLOCK_BIT_VIRT, &bp->bits))
 		vfree(bp->virt);
 	else
@@ -441,7 +441,7 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 	sector_t sector;
 	int ret = 0;
 
-	sector = bp->bl.blkno << (SCOUTFS_BLOCK_SHIFT - 9);
+	sector = bp->bl.blkno << (SCOUTFS_BLOCK_LG_SHIFT - 9);
 
 	WARN_ON_ONCE(bp->bl.blkno == U64_MAX);
 	WARN_ON_ONCE(sector == U64_MAX || sector == 0);
@@ -453,9 +453,9 @@ static int block_submit_bio(struct super_block *sb, struct block_private *bp,
 
 	blk_start_plug(&plug);
 
-	for (off = 0; off < SCOUTFS_BLOCK_SIZE; off += PAGE_SIZE) {
+	for (off = 0; off < SCOUTFS_BLOCK_LG_SIZE; off += PAGE_SIZE) {
 		if (!bio) {
-			bio = bio_alloc(GFP_NOFS, SCOUTFS_PAGES_PER_BLOCK);
+			bio = bio_alloc(GFP_NOFS, SCOUTFS_BLOCK_LG_PAGES_PER);
 			if (!bio) {
 				ret = -ENOMEM;
 				break;
@@ -634,6 +634,7 @@ void scoutfs_block_invalidate(struct super_block *sb, struct scoutfs_block *bl)
 	}
 }
 
+/* This is only used for large metadata blocks */
 bool scoutfs_block_consistent_ref(struct super_block *sb,
 				  struct scoutfs_block *bl,
 				  __le64 seq, __le64 blkno, u32 magic)
@@ -643,7 +644,8 @@ bool scoutfs_block_consistent_ref(struct super_block *sb,
 	struct scoutfs_block_header *hdr = bl->data;
 
 	if (!test_bit(BLOCK_BIT_CRC_VALID, &bp->bits)) {
-		if (hdr->crc != scoutfs_block_calc_crc(hdr))
+		if (hdr->crc !=
+		    scoutfs_block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE))
 			return false;
 		set_bit(BLOCK_BIT_CRC_VALID, &bp->bits);
 	}
@@ -722,7 +724,7 @@ int scoutfs_block_writer_write(struct super_block *sb,
 	/* checksum everything to reduce time between io submission merging */
 	list_for_each_entry(bp, &wri->dirty_list, dirty_entry) {
 		hdr = bp->bl.data;
-		hdr->crc = scoutfs_block_calc_crc(hdr);
+		hdr->crc = scoutfs_block_calc_crc(hdr, SCOUTFS_BLOCK_LG_SIZE);
 	}
 
         blk_start_plug(&plug);
@@ -866,7 +868,7 @@ bool scoutfs_block_writer_has_dirty(struct super_block *sb,
 u64 scoutfs_block_writer_dirty_bytes(struct super_block *sb,
 				     struct scoutfs_block_writer *wri)
 {
-	return wri->nr_dirty_blocks * SCOUTFS_BLOCK_SIZE;
+	return wri->nr_dirty_blocks * SCOUTFS_BLOCK_LG_SIZE;
 }
 
 /*
@@ -916,12 +918,9 @@ static int block_shrink(struct shrinker *shrink, struct shrink_control *sc)
 	spin_unlock(&binf->lock);
 
 out:
-	return min_t(u64, binf->lru_nr * SCOUTFS_PAGES_PER_BLOCK, INT_MAX);
+	return min_t(u64, binf->lru_nr * SCOUTFS_BLOCK_LG_PAGES_PER, INT_MAX);
 }
 
-#define SCOUTFS_SM_BLOCK_SHIFT	12
-#define SCOUTFS_SM_BLOCK_SIZE	(1 << SCOUTFS_SM_BLOCK_SHIFT)
-
 struct sm_block_completion {
 	struct completion comp;
 	int err;
@@ -956,11 +955,9 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno,
 	struct bio *bio;
 	int ret;
 
-	BUILD_BUG_ON(PAGE_SIZE < SCOUTFS_SM_BLOCK_SIZE);
-	/* block calc crc is assuming block size, they'll be different later */
-	BUILD_BUG_ON(SCOUTFS_SM_BLOCK_SIZE != SCOUTFS_BLOCK_SIZE);
+	BUILD_BUG_ON(PAGE_SIZE < SCOUTFS_BLOCK_SM_SIZE);
 
-	if (WARN_ON_ONCE(len > SCOUTFS_SM_BLOCK_SIZE) ||
+	if (WARN_ON_ONCE(len > SCOUTFS_BLOCK_SM_SIZE) ||
 	    WARN_ON_ONCE(!(rw & WRITE) && !blk_crc))
 		return -EINVAL;
 
@@ -972,10 +969,11 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno,
 
 	if (rw & WRITE) {
 		memcpy(pg_hdr, hdr, len);
-		if (len < SCOUTFS_SM_BLOCK_SIZE)
+		if (len < SCOUTFS_BLOCK_SM_SIZE)
 			memset((char *)pg_hdr + len, 0,
-			       SCOUTFS_SM_BLOCK_SIZE - len);
-		pg_hdr->crc = scoutfs_block_calc_crc(pg_hdr);
+			       SCOUTFS_BLOCK_SM_SIZE - len);
+		pg_hdr->crc = scoutfs_block_calc_crc(pg_hdr,
+						     SCOUTFS_BLOCK_SM_SIZE);
 	}
 
 	bio = bio_alloc(GFP_NOFS, 1);
@@ -984,11 +982,11 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno,
 		goto out;
 	}
 
-	bio->bi_sector = blkno << (SCOUTFS_SM_BLOCK_SHIFT - 9);
+	bio->bi_sector = blkno << (SCOUTFS_BLOCK_SM_SHIFT - 9);
 	bio->bi_bdev = sb->s_bdev;
 	bio->bi_end_io = sm_block_bio_end_io;
 	bio->bi_private = &sbc;
-	bio_add_page(bio, page, SCOUTFS_SM_BLOCK_SIZE, 0);
+	bio_add_page(bio, page, SCOUTFS_BLOCK_SM_SIZE, 0);
 
 	init_completion(&sbc.comp);
 	sbc.err = 0;
@@ -1000,7 +998,8 @@ static int sm_block_io(struct super_block *sb, int rw, u64 blkno,
 
 	if (ret == 0 && !(rw & WRITE)) {
 		memcpy(hdr, pg_hdr, len);
-		*blk_crc = scoutfs_block_calc_crc(pg_hdr);
+		*blk_crc = scoutfs_block_calc_crc(pg_hdr,
+						  SCOUTFS_BLOCK_SM_SIZE);
 	}
 out:
 	__free_page(page);
diff --git a/kmod/src/block.h b/kmod/src/block.h
index dc62bf77..57e849a5 100644
--- a/kmod/src/block.h
+++ b/kmod/src/block.h
@@ -12,8 +12,8 @@ struct scoutfs_block {
 	void *data;
 };
 
-__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr);
-bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr);
+__le32 scoutfs_block_calc_crc(struct scoutfs_block_header *hdr, u32 size);
+bool scoutfs_block_valid_crc(struct scoutfs_block_header *hdr, u32 size);
 bool scoutfs_block_valid_ref(struct super_block *sb,
 			     struct scoutfs_block_header *hdr,
 			     __le64 seq, __le64 blkno);
diff --git a/kmod/src/btree.c b/kmod/src/btree.c
index 7edee5b6..969b831a 100644
--- a/kmod/src/btree.c
+++ b/kmod/src/btree.c
@@ -111,7 +111,7 @@ static inline unsigned int item_bytes(struct scoutfs_btree_item *item)
  */
 static unsigned int join_low_watermark(void)
 {
-	return (SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block)) / 4;
+	return (SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block)) / 4;
 }
 
 /*
@@ -121,7 +121,7 @@ static unsigned int join_low_watermark(void)
 static unsigned int item_full_pct(struct scoutfs_btree_block *bt)
 {
 	return (int)le16_to_cpu(bt->total_item_bytes) * 100 /
-		(SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block));
+		(SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block));
 }
 
 static inline __le16 ptr_off(struct scoutfs_btree_block *bt, void *ptr)
@@ -216,7 +216,7 @@ static int leaf_item_hash_ind(struct scoutfs_key *key)
 
 static __le16 *leaf_item_hash_buckets(struct scoutfs_btree_block *bt)
 {
-	return (void *)bt + SCOUTFS_BLOCK_SIZE -
+	return (void *)bt + SCOUTFS_BLOCK_LG_SIZE -
 		SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES;
 }
 
@@ -760,11 +760,11 @@ retry:
 
 	if (bt) {
 		/* returning a cow of an existing block */
-		memcpy(new, bt, SCOUTFS_BLOCK_SIZE);
+		memcpy(new, bt, SCOUTFS_BLOCK_LG_SIZE);
 		scoutfs_block_put(sb, bl);
 	} else {
 		/* returning a newly allocated block */
-		memset(new, 0, SCOUTFS_BLOCK_SIZE);
+		memset(new, 0, SCOUTFS_BLOCK_LG_SIZE);
 		new->hdr.fsid = super->hdr.fsid;
 	}
 	bl = new_bl;
@@ -828,7 +828,7 @@ static void init_btree_block(struct scoutfs_btree_block *bt, int level)
 {
 	int free;
 
-	free = SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block);
+	free = SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block);
 	if (level == 0)
 		free -= SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES;
 
diff --git a/kmod/src/count.h b/kmod/src/count.h
index b2dd8152..176321d0 100644
--- a/kmod/src/count.h
+++ b/kmod/src/count.h
@@ -245,9 +245,9 @@ static inline const struct scoutfs_item_count SIC_XATTR_SET(unsigned old_parts,
 static inline const struct scoutfs_item_count SIC_WRITE_BEGIN(void)
 {
 	struct scoutfs_item_count cnt = {0,};
-	unsigned nr_free = (1 + SCOUTFS_BLOCKS_PER_PAGE) * 3;
-	unsigned nr_file = (DIV_ROUND_UP(SCOUTFS_BLOCKS_PER_PAGE, 2) +
-			    SCOUTFS_BLOCKS_PER_PAGE) * 3;
+	unsigned nr_free = (1 + SCOUTFS_BLOCK_SM_PER_PAGE) * 3;
+	unsigned nr_file = (DIV_ROUND_UP(SCOUTFS_BLOCK_SM_PER_PAGE, 2) +
+			    SCOUTFS_BLOCK_SM_PER_PAGE) * 3;
 
 	__count_dirty_inode(&cnt);
 
diff --git a/kmod/src/data.c b/kmod/src/data.c
index b129aa42..ed42bb8a 100644
--- a/kmod/src/data.c
+++ b/kmod/src/data.c
@@ -803,8 +803,8 @@ int scoutfs_data_truncate_items(struct super_block *sb, struct inode *inode,
 	WARN_ON_ONCE(inode && !mutex_is_locked(&inode->i_mutex));
 
 	/* clamp last to the last possible block? */
-	if (last > SCOUTFS_BLOCK_MAX)
-		last = SCOUTFS_BLOCK_MAX;
+	if (last > SCOUTFS_BLOCK_SM_MAX)
+		last = SCOUTFS_BLOCK_SM_MAX;
 
 	trace_scoutfs_data_truncate_items(sb, iblock, last, offline);
 
@@ -1060,7 +1060,7 @@ out:
 		offset = iblock - ext->iblock;
 		map_bh(bh, inode->i_sb, ext->blkno + offset);
 		bh->b_size = min_t(u64, bh->b_size,
-				(ext->count - offset) << SCOUTFS_BLOCK_SHIFT);
+			     (ext->count - offset) << SCOUTFS_BLOCK_SM_SHIFT);
 	}
 
 	if (ext)
@@ -1483,8 +1483,8 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
                         goto out;
         }
 
-	iblock = offset >> SCOUTFS_BLOCK_SHIFT;
-	last = (offset + len - 1) >> SCOUTFS_BLOCK_SHIFT;
+	iblock = offset >> SCOUTFS_BLOCK_SM_SHIFT;
+	last = (offset + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
 
 	while(iblock <= last) {
 
@@ -1496,7 +1496,7 @@ long scoutfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
 		ret = fallocate_extents(sb, inode, iblock, last, lock);
 
 		if (ret >= 0 && !(mode & FALLOC_FL_KEEP_SIZE)) {
-			end = (iblock + ret) << SCOUTFS_BLOCK_SHIFT;
+			end = (iblock + ret) << SCOUTFS_BLOCK_SM_SHIFT;
 			if (end > offset + len)
 				end = offset + len;
 			if (end > i_size_read(inode))
@@ -1549,7 +1549,7 @@ int scoutfs_data_init_offline_extent(struct inode *inode, u64 size,
 	u64 off;
 	int ret;
 
-	blocks = DIV_ROUND_UP(size, SCOUTFS_BLOCK_SIZE);
+	blocks = DIV_ROUND_UP(size, SCOUTFS_BLOCK_SM_SIZE);
 
 	scoutfs_inode_get_onoff(inode, &on, &off);
 	iblock = off;
@@ -1622,9 +1622,9 @@ static int fill_extent(struct fiemap_extent_info *fieinfo,
 		flags |= FIEMAP_EXTENT_UNWRITTEN;
 
 	return fiemap_fill_next_extent(fieinfo,
-				       ext->iblock << SCOUTFS_BLOCK_SHIFT,
-				       ext->blkno << SCOUTFS_BLOCK_SHIFT,
-				       ext->count << SCOUTFS_BLOCK_SHIFT,
+				       ext->iblock << SCOUTFS_BLOCK_SM_SHIFT,
+				       ext->blkno << SCOUTFS_BLOCK_SM_SHIFT,
+				       ext->count << SCOUTFS_BLOCK_SM_SHIFT,
 				       flags);
 }
 
@@ -1666,8 +1666,8 @@ int scoutfs_data_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 	memset(&cur, 0, sizeof(cur));
 	last_flags = 0;
 
-	iblock = start >> SCOUTFS_BLOCK_SHIFT;
-	last = (start + len - 1) >> SCOUTFS_BLOCK_SHIFT;
+	iblock = start >> SCOUTFS_BLOCK_SM_SHIFT;
+	last = (start + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
 
 	for (;;) {
 		ret = load_unpacked_extents(sb, ino, iblock, last, false,
@@ -1831,8 +1831,8 @@ int scoutfs_data_wait_check(struct inode *inode, loff_t pos, loff_t len,
 		}
 	}
 
-	iblock = pos >> SCOUTFS_BLOCK_SHIFT;
-	last_block = (pos + len - 1) >> SCOUTFS_BLOCK_SHIFT;
+	iblock = pos >> SCOUTFS_BLOCK_SM_SHIFT;
+	last_block = (pos + len - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
 
 	while(iblock <= last_block) {
 
@@ -2056,7 +2056,8 @@ u64 scoutfs_data_alloc_free_bytes(struct super_block *sb)
 {
 	DECLARE_DATA_INFO(sb, datinf);
 
-	return scoutfs_radix_root_free_bytes(sb, &datinf->data_avail);
+	return scoutfs_radix_root_free_blocks(sb, &datinf->data_avail) <<
+		SCOUTFS_BLOCK_SM_SHIFT;
 }
 
 int scoutfs_data_setup(struct super_block *sb)
diff --git a/kmod/src/forest.c b/kmod/src/forest.c
index af44204e..9bad162e 100644
--- a/kmod/src/forest.c
+++ b/kmod/src/forest.c
@@ -1163,9 +1163,9 @@ static int set_lock_bloom_bits(struct super_block *sb,
 			err = scoutfs_radix_free(sb, finf->alloc, finf->wri,
 						  le64_to_cpu(ref->blkno));
 			BUG_ON(err); /* could have dirtied */
-			memcpy(new_bl->data, bl->data, SCOUTFS_BLOCK_SIZE);
+			memcpy(new_bl->data, bl->data, SCOUTFS_BLOCK_LG_SIZE);
 		} else {
-			memset(new_bl->data, 0, SCOUTFS_BLOCK_SIZE);
+			memset(new_bl->data, 0, SCOUTFS_BLOCK_LG_SIZE);
 		}
 
 		scoutfs_block_writer_mark_dirty(sb, finf->wri, new_bl);
diff --git a/kmod/src/format.h b/kmod/src/format.h
index 822675e6..6c667c97 100644
--- a/kmod/src/format.h
+++ b/kmod/src/format.h
@@ -11,24 +11,42 @@
 #define SCOUTFS_BLOCK_MAGIC_RADIX	0xebeb5e65
 
 /*
- * The super block and btree blocks are fixed 4k.
+ * The super block, quorum block, and file data allocation granularity
+ * use the smaller 4KB block.
  */
-#define SCOUTFS_BLOCK_SHIFT 12
-#define SCOUTFS_BLOCK_SIZE (1 << SCOUTFS_BLOCK_SHIFT)
-#define SCOUTFS_BLOCK_MASK (SCOUTFS_BLOCK_SIZE - 1)
-#define SCOUTFS_BLOCKS_PER_PAGE (PAGE_SIZE / SCOUTFS_BLOCK_SIZE)
-#define SCOUTFS_BLOCK_SECTOR_SHIFT (SCOUTFS_BLOCK_SHIFT - 9)
-#define SCOUTFS_BLOCK_SECTORS (1 << SCOUTFS_BLOCK_SECTOR_SHIFT)
-#define SCOUTFS_BLOCK_MAX (U64_MAX >> SCOUTFS_BLOCK_SHIFT)
+#define SCOUTFS_BLOCK_SM_SHIFT		12
+#define SCOUTFS_BLOCK_SM_SIZE		(1 << SCOUTFS_BLOCK_SM_SHIFT)
+#define SCOUTFS_BLOCK_SM_MASK		(SCOUTFS_BLOCK_SM_SIZE - 1)
+#define SCOUTFS_BLOCK_SM_PER_PAGE	(PAGE_SIZE / SCOUTFS_BLOCK_SM_SIZE)
+#define SCOUTFS_BLOCK_SM_SECTOR_SHIFT	(SCOUTFS_BLOCK_SM_SHIFT - 9)
+#define SCOUTFS_BLOCK_SM_SECTORS	(1 << SCOUTFS_BLOCK_SM_SECTOR_SHIFT)
+#define SCOUTFS_BLOCK_SM_MAX		(U64_MAX >> SCOUTFS_BLOCK_SM_SHIFT)
+#define SCOUTFS_BLOCK_SM_PAGES_PER	(SCOUTFS_BLOCK_SM_SIZE / PAGE_SIZE)
+#define SCOUTFS_BLOCK_SM_PAGE_ORDER	(SCOUTFS_BLOCK_SM_SHIFT - PAGE_SHIFT)
+
+/*
+ * The radix and btree structures, and the forest bloom block, use the
+ * larger 64KB metadata block size.
+ */
+#define SCOUTFS_BLOCK_LG_SHIFT		16
+#define SCOUTFS_BLOCK_LG_SIZE		(1 << SCOUTFS_BLOCK_LG_SHIFT)
+#define SCOUTFS_BLOCK_LG_MASK		(SCOUTFS_BLOCK_LG_SIZE - 1)
+#define SCOUTFS_BLOCK_LG_PER_PAGE	(PAGE_SIZE / SCOUTFS_BLOCK_LG_SIZE)
+#define SCOUTFS_BLOCK_LG_SECTOR_SHIFT	(SCOUTFS_BLOCK_LG_SHIFT - 9)
+#define SCOUTFS_BLOCK_LG_SECTORS	(1 << SCOUTFS_BLOCK_LG_SECTOR_SHIFT)
+#define SCOUTFS_BLOCK_LG_MAX		(U64_MAX >> SCOUTFS_BLOCK_LG_SHIFT)
+#define SCOUTFS_BLOCK_LG_PAGES_PER	(SCOUTFS_BLOCK_LG_SIZE / PAGE_SIZE)
+#define SCOUTFS_BLOCK_LG_PAGE_ORDER	(SCOUTFS_BLOCK_LG_SHIFT - PAGE_SHIFT)
+
+#define SCOUTFS_BLOCK_SM_LG_SHIFT	(SCOUTFS_BLOCK_LG_SHIFT - \
+					 SCOUTFS_BLOCK_SM_SHIFT)
 
-#define SCOUTFS_PAGES_PER_BLOCK (SCOUTFS_BLOCK_SIZE / PAGE_SIZE)
-#define SCOUTFS_BLOCK_PAGE_ORDER (SCOUTFS_BLOCK_SHIFT - PAGE_SHIFT)
 
 /*
  * The super block leaves some room before the first block for platform
  * structures like boot loaders.
  */
-#define SCOUTFS_SUPER_BLKNO ((64ULL * 1024) >> SCOUTFS_BLOCK_SHIFT)
+#define SCOUTFS_SUPER_BLKNO ((64ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT)
 
 /*
  * A reasonably large region of aligned quorum blocks follow the super
@@ -38,8 +56,8 @@
  * mounts that have a reasonable probability of not overwriting each
  * other's random block locations.
  */
-#define SCOUTFS_QUORUM_BLKNO		((256ULL * 1024) >> SCOUTFS_BLOCK_SHIFT)
-#define SCOUTFS_QUORUM_BLOCKS		((256ULL * 1024) >> SCOUTFS_BLOCK_SHIFT)
+#define SCOUTFS_QUORUM_BLKNO	((256ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT)
+#define SCOUTFS_QUORUM_BLOCKS	((256ULL * 1024) >> SCOUTFS_BLOCK_SM_SHIFT)
 
 #define SCOUTFS_UNIQUE_NAME_MAX_BYTES	64 /* includes null */
 
@@ -168,8 +186,9 @@ struct scoutfs_radix_root {
 	struct scoutfs_radix_ref ref;
 } __packed;
 
-#define SCOUTFS_RADIX_REFS \
-	((SCOUTFS_BLOCK_SIZE - offsetof(struct scoutfs_radix_block, refs[0])) /\
+#define SCOUTFS_RADIX_REFS					\
+	((SCOUTFS_BLOCK_LG_SIZE -				\
+	  offsetof(struct scoutfs_radix_block, refs[0])) /	\
 		sizeof(struct scoutfs_radix_ref))
 
 /* 8 meg regions with 4k data blocks */
@@ -178,8 +197,8 @@ struct scoutfs_radix_root {
 #define SCOUTFS_RADIX_LG_MASK	(SCOUTFS_RADIX_LG_BITS - 1)
 
 /* round block bits down to a multiple of large ranges */
-#define SCOUTFS_RADIX_BITS					\
-	(((SCOUTFS_BLOCK_SIZE -					\
+#define SCOUTFS_RADIX_BITS						\
+	(((SCOUTFS_BLOCK_LG_SIZE -					\
 	   offsetof(struct scoutfs_radix_block, bits[0])) * 8) &	\
 	 ~(__u64)SCOUTFS_RADIX_LG_MASK)
 #define SCOUTFS_RADIX_BITS_BYTES (SCOUTFS_RADIX_BITS / 8)
@@ -247,7 +266,7 @@ struct scoutfs_btree_block {
  * blocks aren't full.
  */
 #define SCOUTFS_BTREE_LEAF_ITEM_HASH_NR					  \
-	((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_btree_block)) /	  \
+	((SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_btree_block)) /	  \
 	 (sizeof(struct scoutfs_btree_item) + (sizeof(__le16))) * 100 / 75)
 #define SCOUTFS_BTREE_LEAF_ITEM_HASH_BYTES \
 	(SCOUTFS_BTREE_LEAF_ITEM_HASH_NR * sizeof(__le16))
@@ -313,9 +332,9 @@ struct scoutfs_bloom_block {
  */
 #define SCOUTFS_FOREST_BLOOM_NRS		7
 #define SCOUTFS_FOREST_BLOOM_BITS \
-	(((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_bloom_block)) /	\
-	 member_sizeof(struct scoutfs_bloom_block, bits[0])) *		\
-	 member_sizeof(struct scoutfs_bloom_block, bits[0]) * 8)	\
+	(((SCOUTFS_BLOCK_LG_SIZE - sizeof(struct scoutfs_bloom_block)) /  \
+	 member_sizeof(struct scoutfs_bloom_block, bits[0])) *		  \
+	 member_sizeof(struct scoutfs_bloom_block, bits[0]) * 8)	  \
 
 /*
  * Keys are first sorted by major key zones.
@@ -380,10 +399,10 @@ struct scoutfs_packed_extent {
 	__u8 le_blkno_diff[0];
 } __packed;
 
-#define SCOUTFS_PACKEXT_BLOCKS		(8 * 1024 * 1024 / SCOUTFS_BLOCK_SIZE)
-#define SCOUTFS_PACKEXT_BASE_SHIFT	(ilog2(SCOUTFS_PACKEXT_BLOCKS))
-#define SCOUTFS_PACKEXT_BASE_MASK	(~((__u64)SCOUTFS_PACKEXT_BLOCKS - 1))
-#define SCOUTFS_PACKEXT_MAX_BYTES	SCOUTFS_MAX_VAL_SIZE
+#define SCOUTFS_PACKEXT_BLOCKS	     (8 * 1024 * 1024 / SCOUTFS_BLOCK_SM_SIZE)
+#define SCOUTFS_PACKEXT_BASE_SHIFT   (ilog2(SCOUTFS_PACKEXT_BLOCKS))
+#define SCOUTFS_PACKEXT_BASE_MASK    (~((__u64)SCOUTFS_PACKEXT_BLOCKS - 1))
+#define SCOUTFS_PACKEXT_MAX_BYTES    SCOUTFS_MAX_VAL_SIZE
 
 #define SEF_OFFLINE	(1 << 0)
 #define SEF_UNWRITTEN	(1 << 1)
@@ -445,8 +464,8 @@ struct scoutfs_quorum_block {
 	} __packed log[0];
 } __packed;
 
-#define SCOUTFS_QUORUM_LOG_MAX						\
-	((SCOUTFS_BLOCK_SIZE - sizeof(struct scoutfs_quorum_block)) /	\
+#define SCOUTFS_QUORUM_LOG_MAX						  \
+	((SCOUTFS_BLOCK_SM_SIZE - sizeof(struct scoutfs_quorum_block)) /  \
 		sizeof(struct scoutfs_quorum_log))
 
 struct scoutfs_super_block {
diff --git a/kmod/src/inode.c b/kmod/src/inode.c
index 32ed084e..124d9375 100644
--- a/kmod/src/inode.c
+++ b/kmod/src/inode.c
@@ -244,7 +244,7 @@ static void load_inode(struct inode *inode, struct scoutfs_inode *cinode)
 	 * maintained as blocks come and go.
 	 */
 	inode->i_blocks = (ci->online_blocks + ci->offline_blocks)
-				<< SCOUTFS_BLOCK_SECTOR_SHIFT;
+				<< SCOUTFS_BLOCK_SM_SECTOR_SHIFT;
 
 	set_item_info(ci, cinode);
 }
@@ -390,7 +390,8 @@ int scoutfs_complete_truncate(struct inode *inode, struct scoutfs_lock *lock)
 	if (!(ci->flags & SCOUTFS_INO_FLAG_TRUNCATE))
 		return 0;
 
-	start = (i_size_read(inode) + SCOUTFS_BLOCK_SIZE - 1) >> SCOUTFS_BLOCK_SHIFT;
+	start = (i_size_read(inode) + SCOUTFS_BLOCK_SM_SIZE - 1) >>
+		SCOUTFS_BLOCK_SM_SHIFT;
 	ret = scoutfs_data_truncate_items(inode->i_sb, inode,
 					  scoutfs_ino(inode), start, ~0ULL,
 					  false, lock);
@@ -573,7 +574,7 @@ void scoutfs_inode_add_onoff(struct inode *inode, s64 on, s64 off)
 		si->online_blocks += on;
 		si->offline_blocks += off;
 		/* XXX not sure if this is right */
-		inode->i_blocks += (on + off) * SCOUTFS_BLOCK_SECTORS;
+		inode->i_blocks += (on + off) * SCOUTFS_BLOCK_SM_SECTORS;
 
 		trace_scoutfs_online_offline_blocks(inode, on, off,
 						    si->online_blocks,
diff --git a/kmod/src/ioctl.c b/kmod/src/ioctl.c
index a321a1db..c0dac183 100644
--- a/kmod/src/ioctl.c
+++ b/kmod/src/ioctl.c
@@ -318,8 +318,8 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg)
 	inode_dio_wait(inode);
 
 	/* drop all clean and dirty cached blocks in the range */
-	start = args.block << SCOUTFS_BLOCK_SHIFT;
-	end_inc = ((args.block + args.count) << SCOUTFS_BLOCK_SHIFT) - 1;
+	start = args.block << SCOUTFS_BLOCK_SM_SHIFT;
+	end_inc = ((args.block + args.count) << SCOUTFS_BLOCK_SM_SHIFT) - 1;
 	truncate_inode_pages_range(&inode->i_data, start, end_inc);
 
 	ret = scoutfs_data_truncate_items(sb, inode, scoutfs_ino(inode),
@@ -330,8 +330,8 @@ static long scoutfs_ioc_release(struct file *file, unsigned long arg)
 		scoutfs_inode_get_onoff(inode, &online, &offline);
 		isize = i_size_read(inode);
 		if (online == 0 && isize) {
-			start = (isize + SCOUTFS_BLOCK_SIZE - 1)
-					>> SCOUTFS_BLOCK_SHIFT;
+			start = (isize + SCOUTFS_BLOCK_SM_SIZE - 1)
+					>> SCOUTFS_BLOCK_SM_SHIFT;
 			ret = scoutfs_data_truncate_items(sb, inode,
 							  scoutfs_ino(inode),
 							  start, U64_MAX,
@@ -371,8 +371,8 @@ static long scoutfs_ioc_data_wait_err(struct file *file, unsigned long arg)
 
 	trace_scoutfs_ioc_data_wait_err(sb, &args);
 
-	sblock = args.offset >> SCOUTFS_BLOCK_SHIFT;
-	eblock = (args.offset + args.count - 1) >> SCOUTFS_BLOCK_SHIFT;
+	sblock = args.offset >> SCOUTFS_BLOCK_SM_SHIFT;
+	eblock = (args.offset + args.count - 1) >> SCOUTFS_BLOCK_SM_SHIFT;
 
 	if (sblock > eblock)
 		return -EINVAL;
@@ -460,7 +460,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 
 	/* verify arg constraints that aren't dependent on file */
 	if (args.count < 0 || (end_size < args.offset) ||
-	    args.offset & SCOUTFS_BLOCK_MASK)
+	    args.offset & SCOUTFS_BLOCK_SM_MASK)
 		return -EINVAL;
 
 	if (args.count == 0)
@@ -494,7 +494,7 @@ static long scoutfs_ioc_stage(struct file *file, unsigned long arg)
 	    (file->f_flags & (O_APPEND | O_DIRECT | O_DSYNC)) ||
 	    IS_SYNC(file->f_mapping->host) ||
 	    (end_size > isize) ||
-	    ((end_size & SCOUTFS_BLOCK_MASK) && (end_size != isize))) {
+	    ((end_size & SCOUTFS_BLOCK_SM_MASK) && (end_size != isize))) {
 		ret = -EINVAL;
 		goto out;
 	}
diff --git a/kmod/src/quorum.c b/kmod/src/quorum.c
index a3e7e6d2..e1960fed 100644
--- a/kmod/src/quorum.c
+++ b/kmod/src/quorum.c
@@ -144,7 +144,7 @@ struct quorum_block_head {
 	struct list_head head;
 	union {
 		struct scoutfs_quorum_block blk;
-		u8 bytes[SCOUTFS_BLOCK_SIZE];
+		u8 bytes[SCOUTFS_BLOCK_SM_SIZE];
 	};
 };
 
@@ -184,13 +184,13 @@ static size_t quorum_block_bytes(struct scoutfs_quorum_block *blk)
 static bool invalid_quorum_block(struct buffer_head *bh,
 				 struct scoutfs_quorum_block *blk)
 {
-	return bh->b_size != SCOUTFS_BLOCK_SIZE ||
-	       sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SIZE ||
+	return bh->b_size != SCOUTFS_BLOCK_SM_SIZE ||
+	       sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SM_SIZE ||
 	       quorum_block_crc(blk) != blk->crc ||
 	       le64_to_cpu(blk->blkno) != bh->b_blocknr ||
 	       blk->term == 0 ||
 	       blk->log_nr > SCOUTFS_QUORUM_LOG_MAX ||
-	       quorum_block_bytes(blk) > SCOUTFS_BLOCK_SIZE;
+	       quorum_block_bytes(blk) > SCOUTFS_BLOCK_SM_SIZE;
 }
 
 /* true if a is stale and should be ignored */
@@ -296,7 +296,8 @@ static int write_quorum_block(struct super_block *sb,
 	size_t size;
 	int ret;
 
-	BUILD_BUG_ON(sizeof(struct scoutfs_quorum_block) > SCOUTFS_BLOCK_SIZE);
+	BUILD_BUG_ON(sizeof(struct scoutfs_quorum_block) >
+		     SCOUTFS_BLOCK_SM_SIZE);
 
 	bh = sb_getblk(sb, SCOUTFS_QUORUM_BLKNO +
 			   prandom_u32_max(SCOUTFS_QUORUM_BLOCKS));
@@ -306,8 +307,7 @@ static int write_quorum_block(struct super_block *sb,
 	}
 
 	size = quorum_block_bytes(our_blk);
-	if (WARN_ON_ONCE(size > SCOUTFS_BLOCK_SIZE ||
-			 size > bh->b_size)) {
+	if (WARN_ON_ONCE(size > SCOUTFS_BLOCK_SM_SIZE || size > bh->b_size)) {
 		ret = -EIO;
 		goto out;
 	}
@@ -530,7 +530,7 @@ int scoutfs_quorum_election(struct super_block *sb, ktime_t timeout_abs,
 	trace_scoutfs_quorum_election(sb, prev_term);
 
 	super = kmalloc(sizeof(struct scoutfs_super_block), GFP_NOFS);
-	our_blk = kmalloc(SCOUTFS_BLOCK_SIZE, GFP_NOFS);
+	our_blk = kmalloc(SCOUTFS_BLOCK_SM_SIZE, GFP_NOFS);
 	if (!super || !our_blk) {
 		ret = -ENOMEM;
 		goto out;
@@ -548,7 +548,7 @@ int scoutfs_quorum_election(struct super_block *sb, ktime_t timeout_abs,
 			    SCOUTFS_QUORUM_TERM_HI_MS);
 
 	for (;;) {
-		memset(our_blk, 0, SCOUTFS_BLOCK_SIZE);
+		memset(our_blk, 0, SCOUTFS_BLOCK_SM_SIZE);
 
 		scoutfs_inc_counter(sb, quorum_cycle);
 
diff --git a/kmod/src/radix.c b/kmod/src/radix.c
index e8e39b42..f7b61483 100644
--- a/kmod/src/radix.c
+++ b/kmod/src/radix.c
@@ -83,7 +83,7 @@
  * stubbed out refs that reference entirely empty or full subtrees.
  * They're moved to properly allocated blknos.
  */
-#define RADIX_SYNTH_BLKNO (SCOUTFS_BLOCK_MAX + 1)
+#define RADIX_SYNTH_BLKNO (SCOUTFS_BLOCK_LG_MAX + 1)
 
 struct radix_path {
 	struct rb_node node;
@@ -763,7 +763,7 @@ static void init_block(struct super_block *sb, struct scoutfs_radix_block *rdx,
 		else
 			memset(rdx->bits, 0, SCOUTFS_RADIX_BITS_BYTES);
 
-		tail = SCOUTFS_BLOCK_SIZE -
+		tail = SCOUTFS_BLOCK_LG_SIZE -
 		       offsetof(struct scoutfs_radix_block, bits) -
 		       SCOUTFS_RADIX_BITS_BYTES;
 	} else {
@@ -772,14 +772,14 @@ static void init_block(struct super_block *sb, struct scoutfs_radix_block *rdx,
 		for (i = 0; i < SCOUTFS_RADIX_REFS; i++)
 			memcpy(&rdx->refs[i], &ref, sizeof(ref));
 
-		tail = SCOUTFS_BLOCK_SIZE -
+		tail = SCOUTFS_BLOCK_LG_SIZE -
 		       offsetof(struct scoutfs_radix_block,
 				refs[SCOUTFS_RADIX_REFS]);
 	}
 
 	/* make sure we don't write uninitialized tail kernel memory to disk */
 	if (tail)
-		memset((void *)rdx + SCOUTFS_BLOCK_SIZE - tail, 0, tail);
+		memset((void *)rdx + SCOUTFS_BLOCK_LG_SIZE - tail, 0, tail);
 }
 
 /* get path flags */
@@ -1529,10 +1529,10 @@ void scoutfs_radix_root_init(struct super_block *sb,
 	init_ref(&root->ref, 0, false);
 }
 
-u64 scoutfs_radix_root_free_bytes(struct super_block *sb,
-				  struct scoutfs_radix_root *root)
+u64 scoutfs_radix_root_free_blocks(struct super_block *sb,
+				   struct scoutfs_radix_root *root)
 {
-	return le64_to_cpu(root->ref.sm_total) << SCOUTFS_BLOCK_SHIFT;
+	return le64_to_cpu(root->ref.sm_total);
 }
 
 /*
diff --git a/kmod/src/radix.h b/kmod/src/radix.h
index 0ca79431..729e810b 100644
--- a/kmod/src/radix.h
+++ b/kmod/src/radix.h
@@ -38,8 +38,8 @@ void scoutfs_radix_init_alloc(struct scoutfs_radix_allocator *alloc,
 			      struct scoutfs_radix_root *freed);
 void scoutfs_radix_root_init(struct super_block *sb,
 			     struct scoutfs_radix_root *root, bool meta);
-u64 scoutfs_radix_root_free_bytes(struct super_block *sb,
-				  struct scoutfs_radix_root *root);
+u64 scoutfs_radix_root_free_blocks(struct super_block *sb,
+				   struct scoutfs_radix_root *root);
 u64 scoutfs_radix_bit_leaf_nr(u64 bit);
 
 #endif
diff --git a/kmod/src/server.c b/kmod/src/server.c
index f6db3179..b4097c65 100644
--- a/kmod/src/server.c
+++ b/kmod/src/server.c
@@ -400,7 +400,7 @@ static int server_get_log_trees(struct super_block *sb,
 		goto unlock;
 
 	/* ensure client has enough free metadata blocks for a transaction */
-	target = (64*1024*1024) / SCOUTFS_BLOCK_SIZE;
+	target = (64*1024*1024) / SCOUTFS_BLOCK_LG_SIZE;
 	if (le64_to_cpu(ltv.meta_avail.ref.sm_total) < target) {
 		count = target - le64_to_cpu(ltv.meta_avail.ref.sm_total);
 
@@ -413,7 +413,7 @@ static int server_get_log_trees(struct super_block *sb,
 	}
 
 	/* ensure client has enough free data blocks for a transaction */
-	target = SCOUTFS_TRANS_DATA_ALLOC_HWM / SCOUTFS_BLOCK_SIZE;
+	target = SCOUTFS_TRANS_DATA_ALLOC_HWM / SCOUTFS_BLOCK_SM_SIZE;
 	if (le64_to_cpu(ltv.data_avail.ref.sm_total) < target) {
 		count = target - le64_to_cpu(ltv.data_avail.ref.sm_total);
 
diff --git a/kmod/src/super.c b/kmod/src/super.c
index 30cabd73..dc3ff01b 100644
--- a/kmod/src/super.c
+++ b/kmod/src/super.c
@@ -103,7 +103,7 @@ static int scoutfs_statfs(struct dentry *dentry, struct kstatfs *kst)
 
 	kst->f_bfree = le64_to_cpu(nstatfs.bfree);
 	kst->f_type = SCOUTFS_SUPER_MAGIC;
-	kst->f_bsize = SCOUTFS_BLOCK_SIZE;
+	kst->f_bsize = SCOUTFS_BLOCK_SM_SIZE;
 	kst->f_blocks = le64_to_cpu(nstatfs.total_blocks);
 	kst->f_bavail = kst->f_bfree;
 
@@ -115,7 +115,7 @@ static int scoutfs_statfs(struct dentry *dentry, struct kstatfs *kst)
 	kst->f_fsid.val[0] = le32_to_cpu(uuid[0]) ^ le32_to_cpu(uuid[1]);
 	kst->f_fsid.val[1] = le32_to_cpu(uuid[2]) ^ le32_to_cpu(uuid[3]);
 	kst->f_namelen = SCOUTFS_NAME_LEN;
-	kst->f_frsize = SCOUTFS_BLOCK_SIZE;
+	kst->f_frsize = SCOUTFS_BLOCK_SM_SIZE;
 	/* the vfs fills f_flags */
 
 	/*
@@ -379,8 +379,8 @@ static int scoutfs_fill_super(struct super_block *sb, void *data, int silent)
 
 	sbi->opts = opts;
 
-	ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SIZE);
-	if (ret != SCOUTFS_BLOCK_SIZE) {
+	ret = sb_set_blocksize(sb, SCOUTFS_BLOCK_SM_SIZE);
+	if (ret != SCOUTFS_BLOCK_SM_SIZE) {
 		scoutfs_err(sb, "failed to set blocksize, returned %d", ret);
 		ret = -EIO;
 		goto out;