diff --git a/kmod/src/Makefile b/kmod/src/Makefile
index 61b12f70..73589b6c 100644
--- a/kmod/src/Makefile
+++ b/kmod/src/Makefile
@@ -6,7 +6,7 @@ CFLAGS_super.o = -DSCOUTFS_GIT_DESCRIBE=\"$(SCOUTFS_GIT_DESCRIBE)\" \
 CFLAGS_scoutfs_trace.o = -I$(src) # define_trace.h double include
  
 scoutfs-y += bio.o btree.o client.o compact.o counters.o data.o dir.o \
-	     export.o extents.o file.o inode.o ioctl.o item.o key.o lock.o \
+	     export.o extents.o file.o inode.o ioctl.o item.o lock.o \
 	     manifest.o msg.o options.o per_task.o seg.o server.o \
 	     scoutfs_trace.o sock.o sort_priv.o super.o sysfs.o trans.o \
 	     triggers.o xattr.o
diff --git a/kmod/src/key.c b/kmod/src/key.c
deleted file mode 100644
index 9c1603b5..00000000
--- a/kmod/src/key.c
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2018 Versity Software, Inc.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License v2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-#include <linux/kernel.h>
-#include <linux/bug.h>
-#include <linux/errno.h>
-
-#include "format.h"
-#include "key.h"
-
-char *scoutfs_zone_strings[SCOUTFS_MAX_ZONE] = {
-	[SCOUTFS_INODE_INDEX_ZONE]	= "ind",
-	[SCOUTFS_NODE_ZONE]		= "nod",
-	[SCOUTFS_FS_ZONE]		= "fs",
-};
-
-char *scoutfs_type_strings[SCOUTFS_MAX_ZONE][SCOUTFS_MAX_TYPE] = {
-	[SCOUTFS_INODE_INDEX_ZONE][SCOUTFS_INODE_INDEX_META_SEQ_TYPE] = "msq",
-	[SCOUTFS_INODE_INDEX_ZONE][SCOUTFS_INODE_INDEX_DATA_SEQ_TYPE] = "dsq",
-	[SCOUTFS_NODE_ZONE][SCOUTFS_FREE_EXTENT_BLKNO_TYPE]	      = "fbn",
-	[SCOUTFS_NODE_ZONE][SCOUTFS_FREE_EXTENT_BLOCKS_TYPE]	      = "fbs",
-	[SCOUTFS_NODE_ZONE][SCOUTFS_ORPHAN_TYPE]		      = "orp",
-	[SCOUTFS_FS_ZONE][SCOUTFS_INODE_TYPE]			      = "ino",
-	[SCOUTFS_FS_ZONE][SCOUTFS_XATTR_TYPE]			      = "xat",
-	[SCOUTFS_FS_ZONE][SCOUTFS_DIRENT_TYPE]			      = "dnt",
-	[SCOUTFS_FS_ZONE][SCOUTFS_READDIR_TYPE]			      = "rdr",
-	[SCOUTFS_FS_ZONE][SCOUTFS_LINK_BACKREF_TYPE]		      = "lbr",
-	[SCOUTFS_FS_ZONE][SCOUTFS_SYMLINK_TYPE]			      = "sym",
-	[SCOUTFS_FS_ZONE][SCOUTFS_FILE_EXTENT_TYPE]		      = "fex",
-};
-
-char scoutfs_unknown_u8_strings[U8_MAX][U8_STR_MAX];
-
-int __init scoutfs_key_init(void)
-{
-	int ret;
-	int i;
-
-	for (i = 0; i <= U8_MAX; i++) {
-		ret = snprintf(scoutfs_unknown_u8_strings[i], U8_STR_MAX,
-			       "u%u", i);
-		if (WARN_ONCE(ret <= 0 || ret >= U8_STR_MAX,
-			      "snprintf("__stringify(U8_STR_MAX)") ret %d\n",
-			      ret))
-			return -EINVAL;
-	}
-
-	return 0;
-}
diff --git a/kmod/src/key.h b/kmod/src/key.h
index eb157279..abe89ee0 100644
--- a/kmod/src/key.h
+++ b/kmod/src/key.h
@@ -6,39 +6,52 @@
 #include "cmp.h"
 #include "endian_swap.h"
 
-extern char *scoutfs_zone_strings[SCOUTFS_MAX_ZONE];
-extern char *scoutfs_type_strings[SCOUTFS_MAX_ZONE][SCOUTFS_MAX_TYPE];
-#define U8_STR_MAX 5 /* u%3u'\0' */
-extern char scoutfs_unknown_u8_strings[U8_MAX][U8_STR_MAX];
+#define SK_FMT		"%u.%llu.%u.%llu.%llu.%u"
 
-int __init scoutfs_key_init(void);
-
-static inline char *sk_zone_str(u8 zone)
-{
-	if (zone >= SCOUTFS_MAX_ZONE || scoutfs_zone_strings[zone] == NULL)
-		return scoutfs_unknown_u8_strings[zone];
-
-	return scoutfs_zone_strings[zone];
-}
-
-static inline char *sk_type_str(u8 zone, u8 type)
-{
-	if (zone >= SCOUTFS_MAX_ZONE || type >= SCOUTFS_MAX_TYPE ||
-	    scoutfs_type_strings[zone][type] == NULL)
-		return scoutfs_unknown_u8_strings[type];
-
-	return scoutfs_type_strings[zone][type];
-}
-
-#define SK_FMT		"%s.%llu.%s.%llu.%llu.%u"
 /* This does not support null keys */
-#define SK_ARG(key)	sk_zone_str((key)->sk_zone),			\
-			le64_to_cpu((key)->_sk_first),			\
-			sk_type_str((key)->sk_zone, (key)->sk_type),	\
-			le64_to_cpu((key)->_sk_second),			\
-			le64_to_cpu((key)->_sk_third),			\
+#define SK_ARG(key)	(key)->sk_zone,			\
+			le64_to_cpu((key)->_sk_first),	\
+			(key)->sk_type,			\
+			le64_to_cpu((key)->_sk_second),	\
+			le64_to_cpu((key)->_sk_third),	\
 			(key)->_sk_fourth
 
+/* userspace trace event printing doesn't like arguments with structure
+ * field references.  So we explode structures into their fields instead
+ * of
+ */
+#define sk_trace_define(name)			\
+	__field(__u8, name##_zone)		\
+	__field(__u64, name##_first)		\
+	__field(__u8, name##_type)		\
+	__field(__u64, name##_second)		\
+	__field(__u64, name##_third)		\
+	__field(__u8, name##_fourth)
+
+#define sk_trace_assign(name, key)					\
+do {									\
+	__typeof__(key) _key = (key);					\
+	if (_key) {							\
+		__entry->name##_zone = _key->sk_zone;			\
+		__entry->name##_first = le64_to_cpu(_key->_sk_first);	\
+		__entry->name##_type = _key->sk_type;			\
+		__entry->name##_second = le64_to_cpu(_key->_sk_second);\
+		__entry->name##_third = le64_to_cpu(_key->_sk_third);	\
+		__entry->name##_fourth = _key->_sk_fourth;		\
+	} else {							\
+		__entry->name##_zone = 0;				\
+		__entry->name##_first = 0;				\
+		__entry->name##_type = 0;				\
+		__entry->name##_second = 0;				\
+		__entry->name##_third = 0;				\
+		__entry->name##_fourth = 0;				\
+	}								\
+} while (0)
+
+#define sk_trace_args(name) \
+	__entry->name##_zone, __entry->name##_first, __entry->name##_type, \
+	__entry->name##_second, __entry->name##_third, __entry->name##_fourth
+
 static inline void scoutfs_key_set_zeros(struct scoutfs_key *key)
 {
 	key->sk_zone = 0;
diff --git a/kmod/src/scoutfs_trace.h b/kmod/src/scoutfs_trace.h
index 56eae869..dc7568b0 100644
--- a/kmod/src/scoutfs_trace.h
+++ b/kmod/src/scoutfs_trace.h
@@ -235,18 +235,18 @@ DECLARE_EVENT_CLASS(scoutfs_key_ret_class,
 
 	TP_STRUCT__entry(
 		__field(__u64, fsid)
-		__field_struct(struct scoutfs_key, key)
+		sk_trace_define(key)
 		__field(int, ret)
 	),
 
 	TP_fast_assign(
 		__entry->fsid = FSID_ARG(sb);
-		__entry->key = *key;
+		sk_trace_assign(key, key);
 		__entry->ret = ret;
 	),
 
 	TP_printk("fsid "FSID_FMT" key "SK_FMT" ret %d",
-		  __entry->fsid, SK_ARG(&__entry->key), __entry->ret)
+		  __entry->fsid, sk_trace_args(key), __entry->ret)
 );
 
 DEFINE_EVENT(scoutfs_key_ret_class, scoutfs_item_create,
@@ -1243,19 +1243,19 @@ DECLARE_EVENT_CLASS(scoutfs_manifest_class,
 		__field(u8, level)
 		__field(u64, segno)
 		__field(u64, seq)
-		__field_struct(struct scoutfs_key, first)
-		__field_struct(struct scoutfs_key, last)
+		sk_trace_define(first)
+		sk_trace_define(last)
         ),
         TP_fast_assign(
 		__entry->level = level;
 		__entry->segno = segno;
 		__entry->seq = seq;
-		scoutfs_key_copy_or_zeros(&__entry->first, first);
-		scoutfs_key_copy_or_zeros(&__entry->last, last);
+		sk_trace_assign(first, first);
+		sk_trace_assign(last, last);
         ),
         TP_printk("level %u segno %llu seq %llu first "SK_FMT" last "SK_FMT,
 		  __entry->level, __entry->segno, __entry->seq,
-		  SK_ARG(&__entry->first), SK_ARG(&__entry->last))
+		  sk_trace_args(first), sk_trace_args(last))
 );
 
 DEFINE_EVENT(scoutfs_manifest_class, scoutfs_manifest_add,
@@ -1292,24 +1292,24 @@ TRACE_EVENT(scoutfs_read_item_keys,
         TP_ARGS(sb, key, start, end, seg_start, seg_end),
         TP_STRUCT__entry(
 		__field(__u64, fsid)
-		__field_struct(struct scoutfs_key, key)
-		__field_struct(struct scoutfs_key, start)
-		__field_struct(struct scoutfs_key, end)
-		__field_struct(struct scoutfs_key, seg_start)
-		__field_struct(struct scoutfs_key, seg_end)
+		sk_trace_define(key)
+		sk_trace_define(start)
+		sk_trace_define(end)
+		sk_trace_define(seg_start)
+		sk_trace_define(seg_end)
         ),
         TP_fast_assign(
 		__entry->fsid = FSID_ARG(sb);
-		scoutfs_key_copy_or_zeros(&__entry->key, key);
-		scoutfs_key_copy_or_zeros(&__entry->start, start);
-		scoutfs_key_copy_or_zeros(&__entry->end, end);
-		scoutfs_key_copy_or_zeros(&__entry->seg_start, seg_start);
-		scoutfs_key_copy_or_zeros(&__entry->seg_end, seg_end);
+		sk_trace_assign(key, key);
+		sk_trace_assign(start, start);
+		sk_trace_assign(end, end);
+		sk_trace_assign(seg_start, seg_start);
+		sk_trace_assign(seg_end, seg_end);
         ),
         TP_printk("fsid "FSID_FMT" key "SK_FMT" start "SK_FMT" end "SK_FMT" seg_start "SK_FMT" seg_end "SK_FMT"",
-		  __entry->fsid, SK_ARG(&__entry->key), SK_ARG(&__entry->start),
-		  SK_ARG(&__entry->end), SK_ARG(&__entry->seg_start),
-		  SK_ARG(&__entry->seg_end))
+		  __entry->fsid, sk_trace_args(key), sk_trace_args(start),
+		  sk_trace_args(end), sk_trace_args(seg_start),
+		  sk_trace_args(seg_end))
 );
 
 DECLARE_EVENT_CLASS(scoutfs_key_class,
@@ -1317,13 +1317,13 @@ DECLARE_EVENT_CLASS(scoutfs_key_class,
         TP_ARGS(sb, key),
         TP_STRUCT__entry(
  		__field(__u64, fsid)
-		__field_struct(struct scoutfs_key, key)
+		sk_trace_define(key)
         ),
         TP_fast_assign(
 		__entry->fsid = FSID_ARG(sb);
-		scoutfs_key_copy_or_zeros(&__entry->key, key);
+		sk_trace_assign(key, key);
         ),
-	TP_printk(FSID_FMT" key "SK_FMT, __entry->fsid, SK_ARG(&__entry->key))
+	TP_printk(FSID_FMT" key "SK_FMT, __entry->fsid, sk_trace_args(key))
 );
 
 DEFINE_EVENT(scoutfs_key_class, scoutfs_item_lookup,
@@ -1370,17 +1370,16 @@ DECLARE_EVENT_CLASS(scoutfs_range_class,
         TP_ARGS(sb, start, end),
         TP_STRUCT__entry(
 		__field(__u64, fsid)
-		__field_struct(struct scoutfs_key, start)
-		__field_struct(struct scoutfs_key, end)
+		sk_trace_define(start)
+		sk_trace_define(end)
         ),
         TP_fast_assign(
 		__entry->fsid = FSID_ARG(sb);
-		scoutfs_key_copy_or_zeros(&__entry->start, start);
-		scoutfs_key_copy_or_zeros(&__entry->end, end);
+		sk_trace_assign(start, start);
+		sk_trace_assign(end, end);
         ),
         TP_printk("fsid "FSID_FMT" start "SK_FMT" end "SK_FMT,
-		  __entry->fsid, SK_ARG(&__entry->start),
-		  SK_ARG(&__entry->end))
+		  __entry->fsid, sk_trace_args(start), sk_trace_args(end))
 );
 
 DEFINE_EVENT(scoutfs_range_class, scoutfs_item_insert_batch,
@@ -1402,18 +1401,18 @@ DECLARE_EVENT_CLASS(scoutfs_cached_range_class,
         TP_STRUCT__entry(
 		__field(__u64, fsid)
 		__field(void *, rng)
-		__field_struct(struct scoutfs_key, start)
-		__field_struct(struct scoutfs_key, end)
+		sk_trace_define(start)
+		sk_trace_define(end)
         ),
         TP_fast_assign(
 		__entry->fsid = FSID_ARG(sb);
 		__entry->rng = rng;
-		scoutfs_key_copy_or_zeros(&__entry->start, start);
-		scoutfs_key_copy_or_zeros(&__entry->end, end);
+		sk_trace_assign(start, start);
+		sk_trace_assign(end, end);
         ),
         TP_printk("fsid "FSID_FMT" rng %p start "SK_FMT" end "SK_FMT,
-		  __entry->fsid, __entry->rng, SK_ARG(&__entry->start),
-		  SK_ARG(&__entry->end))
+		  __entry->fsid, __entry->rng, sk_trace_args(start),
+		  sk_trace_args(end))
 );
 
 DEFINE_EVENT(scoutfs_cached_range_class, scoutfs_item_range_free,
@@ -1617,7 +1616,7 @@ TRACE_EVENT(scoutfs_seg_append_item,
 		__field(__u64, seq)
 		__field(__u32, nr_items)
 		__field(__u32, total_bytes)
-		__field_struct(struct scoutfs_key, key)
+		sk_trace_define(key)
 		__field(__u16, val_len)
 	),
 
@@ -1627,15 +1626,14 @@ TRACE_EVENT(scoutfs_seg_append_item,
 		__entry->seq = seq;
 		__entry->nr_items = nr_items;
 		__entry->total_bytes = total_bytes;
-		__entry->key = *key;
+		sk_trace_assign(key, key);
 		__entry->val_len = val_len;
 	),
 
 	TP_printk("fsid "FSID_FMT" segno %llu seq %llu nr_items %u total_bytes %u key "SK_FMT" val_len %u",
 		  __entry->fsid, __entry->segno, __entry->seq,
 		  __entry->nr_items, __entry->total_bytes,
-		  SK_ARG(&__entry->key),
-		  __entry->val_len)
+		  sk_trace_args(key), __entry->val_len)
 );
 
 DECLARE_EVENT_CLASS(scoutfs_net_class,
@@ -1753,25 +1751,25 @@ TRACE_EVENT(scoutfs_item_next_range_check,
         TP_STRUCT__entry(
 		__field(void *, sb)
 		__field(int, cached)
-		__field_struct(struct scoutfs_key, key)
-		__field_struct(struct scoutfs_key, pos)
-		__field_struct(struct scoutfs_key, last)
-		__field_struct(struct scoutfs_key, end)
-		__field_struct(struct scoutfs_key, range_end)
+		sk_trace_define(key)
+		sk_trace_define(pos)
+		sk_trace_define(last)
+		sk_trace_define(end)
+		sk_trace_define(range_end)
         ),
         TP_fast_assign(
 		__entry->sb = sb;
 		__entry->cached = cached;
-		scoutfs_key_copy_or_zeros(&__entry->key, key);
-		scoutfs_key_copy_or_zeros(&__entry->pos, pos);
-		scoutfs_key_copy_or_zeros(&__entry->last, last);
-		scoutfs_key_copy_or_zeros(&__entry->end, end);
-		scoutfs_key_copy_or_zeros(&__entry->range_end, range_end);
+		sk_trace_assign(key, key);
+		sk_trace_assign(pos, pos);
+		sk_trace_assign(last, last);
+		sk_trace_assign(end, end);
+		sk_trace_assign(range_end, range_end);
         ),
         TP_printk("sb %p cached %d key "SK_FMT" pos "SK_FMT" last "SK_FMT" end "SK_FMT" range_end "SK_FMT,
-		  __entry->sb, __entry->cached, SK_ARG(&__entry->key),
-		  SK_ARG(&__entry->pos), SK_ARG(&__entry->last),
-		  SK_ARG(&__entry->end), SK_ARG(&__entry->range_end))
+		  __entry->sb, __entry->cached, sk_trace_args(key),
+		  sk_trace_args(pos), sk_trace_args(last),
+		  sk_trace_args(end), sk_trace_args(range_end))
 );
 
 TRACE_EVENT(scoutfs_item_prev_range_check,
@@ -1783,25 +1781,25 @@ TRACE_EVENT(scoutfs_item_prev_range_check,
         TP_STRUCT__entry(
 		__field(void *, sb)
 		__field(int, cached)
-		__field_struct(struct scoutfs_key, key)
-		__field_struct(struct scoutfs_key, pos)
-		__field_struct(struct scoutfs_key, first)
-		__field_struct(struct scoutfs_key, start)
-		__field_struct(struct scoutfs_key, range_start)
+		sk_trace_define(key)
+		sk_trace_define(pos)
+		sk_trace_define(first)
+		sk_trace_define(start)
+		sk_trace_define(range_start)
         ),
         TP_fast_assign(
 		__entry->sb = sb;
 		__entry->cached = cached;
-		scoutfs_key_copy_or_zeros(&__entry->key, key);
-		scoutfs_key_copy_or_zeros(&__entry->pos, pos);
-		scoutfs_key_copy_or_zeros(&__entry->first, first);
-		scoutfs_key_copy_or_zeros(&__entry->start, start);
-		scoutfs_key_copy_or_zeros(&__entry->range_start, range_start);
+		sk_trace_assign(key, key);
+		sk_trace_assign(pos, pos);
+		sk_trace_assign(first, first);
+		sk_trace_assign(start, start);
+		sk_trace_assign(range_start, range_start);
         ),
         TP_printk("sb %p cached %d key "SK_FMT" pos "SK_FMT" first "SK_FMT" start "SK_FMT" range_start "SK_FMT,
-		  __entry->sb, __entry->cached, SK_ARG(&__entry->key),
-		  SK_ARG(&__entry->pos), SK_ARG(&__entry->first),
-		  SK_ARG(&__entry->start), SK_ARG(&__entry->range_start))
+		  __entry->sb, __entry->cached, sk_trace_args(key),
+		  sk_trace_args(pos), sk_trace_args(first),
+		  sk_trace_args(start), sk_trace_args(range_start))
 );
 
 DECLARE_EVENT_CLASS(scoutfs_shrink_exit_class,
@@ -1845,29 +1843,29 @@ TRACE_EVENT(scoutfs_item_shrink_around,
         TP_ARGS(sb, rng_start, rng_end, item, prev, first, last, next),
         TP_STRUCT__entry(
 		__field(void *, sb)
-		__field_struct(struct scoutfs_key, rng_start)
-		__field_struct(struct scoutfs_key, rng_end)
-		__field_struct(struct scoutfs_key, item)
-		__field_struct(struct scoutfs_key, prev)
-		__field_struct(struct scoutfs_key, first)
-		__field_struct(struct scoutfs_key, last)
-		__field_struct(struct scoutfs_key, next)
+		sk_trace_define(rng_start)
+		sk_trace_define(rng_end)
+		sk_trace_define(item)
+		sk_trace_define(prev)
+		sk_trace_define(first)
+		sk_trace_define(last)
+		sk_trace_define(next)
         ),
         TP_fast_assign(
 		__entry->sb = sb;
-		scoutfs_key_copy_or_zeros(&__entry->rng_start, rng_start);
-		scoutfs_key_copy_or_zeros(&__entry->rng_end, rng_end);
-		scoutfs_key_copy_or_zeros(&__entry->item, item);
-		scoutfs_key_copy_or_zeros(&__entry->prev, prev);
-		scoutfs_key_copy_or_zeros(&__entry->first, first);
-		scoutfs_key_copy_or_zeros(&__entry->last, last);
-		scoutfs_key_copy_or_zeros(&__entry->next, next);
+		sk_trace_assign(rng_start, rng_start);
+		sk_trace_assign(rng_end, rng_end);
+		sk_trace_assign(item, item);
+		sk_trace_assign(prev, prev);
+		sk_trace_assign(first, first);
+		sk_trace_assign(last, last);
+		sk_trace_assign(next, next);
         ),
         TP_printk("sb %p rng_start "SK_FMT" rng_end "SK_FMT" item "SK_FMT" prev "SK_FMT" first "SK_FMT" last "SK_FMT" next "SK_FMT,
-		  __entry->sb, SK_ARG(&__entry->rng_start),
-		  SK_ARG(&__entry->rng_end), SK_ARG(&__entry->item),
-		  SK_ARG(&__entry->prev), SK_ARG(&__entry->first),
-		  SK_ARG(&__entry->last), SK_ARG(&__entry->next))
+		  __entry->sb, sk_trace_args(rng_start),
+		  sk_trace_args(rng_end), sk_trace_args(item),
+		  sk_trace_args(prev), sk_trace_args(first),
+		  sk_trace_args(last), sk_trace_args(next))
 );
 
 TRACE_EVENT(scoutfs_rename,
diff --git a/kmod/src/super.c b/kmod/src/super.c
index 6b853766..aaea4cba 100644
--- a/kmod/src/super.c
+++ b/kmod/src/super.c
@@ -419,7 +419,6 @@ static int __init scoutfs_module_init(void)
 		".string	\""SCOUTFS_GIT_DESCRIBE"\\n\"\n"
 		".previous\n");
 
-	scoutfs_key_init();
 	scoutfs_init_counters();
 
 	ret = scoutfs_sysfs_init();