lib9p: protogen: flatten the validate functions, same as (un)marshal

6 files changed, 1784 insertions, 1738 deletions

diff --git a/lib9p/9p.c b/lib9p/9p.c
index 74a786c..78d23a0 100644
--- a/lib9p/9p.c
+++ b/lib9p/9p.c
@@ -128,10 +128,6 @@ ssize_t _lib9p_validate(uint8_t                          xxx_low_typ_bit,
 		.ctx        = ctx,
 		.net_size   = uint32le_decode(net_bytes),
 		.net_bytes  = net_bytes,
-
-		/* output */
-		.net_offset = 0,
-		.host_extra = 0,
 	};
 	if (subctx.net_size < 5)
 		return lib9p_error(ctx, LINUX_EBADMSG, "message is impossibly short");
@@ -145,18 +141,7 @@ ssize_t _lib9p_validate(uint8_t                          xxx_low_typ_bit,
 		                    lib9p_msgtype_str(ctx->version, typ), lib9p_version_str(ctx->version));
 
 	/* Now use the message-type-specific tentry to process the whole thing.  */
-	if (tentry.validate(&subctx))
-		return -1;
-	assert(subctx.net_offset <= subctx.net_size);
-	if (subctx.net_offset < subctx.net_size)
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "message has %"PRIu32" extra bytes",
-		                   subctx.net_size - subctx.net_offset);
-
-	/* Return.  */
-	ssize_t ret;
-	if (__builtin_add_overflow(tentry.basesize, subctx.host_extra, &ret))
-		return lib9p_error(ctx, LINUX_EMSGSIZE, "unmarshalled payload overflows SSIZE_MAX");
-	return ret;
+	return tentry.validate(&subctx);
 }
 
 ssize_t lib9p_Tmsg_validate(struct lib9p_ctx *ctx, uint8_t *net_bytes) {
@@ -251,18 +236,12 @@ bool lib9p_stat_validate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *net_
 		.ctx        = ctx,
 		.net_size   = net_size,
 		.net_bytes  = net_bytes,
-
-		/* output */
-		.net_offset = 0,
-		.host_extra = 0,
 	};
-	if (_lib9p_stat_validate(&subctx))
+	ssize_t host_size = _lib9p_stat_validate(&subctx, ret_net_size);
+	if (host_size < 0)
 		return true;
-	if (ret_net_size)
-		*ret_net_size = subctx.net_offset;
 	if (ret_host_size)
-		if (__builtin_add_overflow(sizeof(struct lib9p_stat), subctx.host_extra, ret_host_size))
-			return lib9p_error(ctx, LINUX_EMSGSIZE, "unmarshalled stat object overflows SSIZE_MAX");
+		*ret_host_size = host_size;
 	return false;
 }
 
diff --git a/lib9p/9p.generated.c b/lib9p/9p.generated.c
index 500d71b..b283be5 100644
--- a/lib9p/9p.generated.c
+++ b/lib9p/9p.generated.c
@@ -416,1599 +416,1562 @@ static const lib9p_lock_flags_t lock_flags_masks[LIB9P_VER_NUM] = {
 
 /* validate_* *****************************************************************/
 
-LM_ALWAYS_INLINE static bool _validate_size_net(struct _validate_ctx *ctx, uint32_t n) {
-	if (__builtin_add_overflow(ctx->net_offset, n, &ctx->net_offset))
-		/* If needed-net-size overflowed uint32_t, then
-		 * there's no way that actual-net-size will live up to
-		 * that.  */
-		return lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-	if (ctx->net_offset > ctx->net_size)
-		return lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool _validate_size_host(struct _validate_ctx *ctx, size_t n) {
-	if (__builtin_add_overflow(ctx->host_extra, n, &ctx->host_extra))
-		/* If needed-host-size overflowed size_t, then there's
-		 * no way that actual-net-size will live up to
-		 * that.  */
+#define VALIDATE_NET_BYTES(n)                                                                    \
+	if (__builtin_add_overflow(net_offset, n, &net_offset))                                  \
+		/* If needed-net-size overflowed uint32_t, then                                  \
+		 * there's no way that actual-net-size will live up to                           \
+		 * that.  */                                                                     \
+		return lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content"); \
+	if (net_offset > ctx->net_size)                                                          \
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "message is too short for content (%"PRIu32" > %"PRIu32") @ %d", net_offset, ctx->net_size, __LINE__);
+#define VALIDATE_NET_UTF8(n)                                                                           \
+	{                                                                                              \
+		size_t len = n;                                                                        \
+		VALIDATE_NET_BYTES(len);                                                               \
+		if (!is_valid_utf8_without_nul(&ctx->net_bytes[net_offset-len], len))                  \
+			return lib9p_error(ctx->ctx, LINUX_EBADMSG, "message contains invalid UTF-8"); \
+	}
+#define RESERVE_HOST_BYTES(n)                                           \
+	if (__builtin_add_overflow(host_size, n, &host_size))           \
+		/* If needed-host-size overflowed ssize_t, then there's \
+		 * no way that actual-net-size will live up to          \
+		 * that.  */                                            \
 		return lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool _validate_list(struct _validate_ctx *ctx,
-                                         size_t cnt,
-                                         _validate_fn_t item_fn, size_t item_host_size) {
-	for (size_t i = 0; i < cnt; i++)
-		if (_validate_size_host(ctx, item_host_size) || item_fn(ctx))
-			return true;
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_1(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 1); }
-LM_ALWAYS_INLINE static bool validate_2(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 2); }
-LM_ALWAYS_INLINE static bool validate_4(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 4); }
-LM_ALWAYS_INLINE static bool validate_8(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 8); }
-
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_tag(struct _validate_ctx *ctx) {
-	return validate_2(ctx);
-}
+#define GET_U8LE(off)  (ctx->net_bytes[off])
+#define GET_U16LE(off) uint16le_decode(&ctx->net_bytes[off])
+#define GET_U32LE(off) uint32le_decode(&ctx->net_bytes[off])
+#define GET_U64LE(off) uint64le_decode(&ctx->net_bytes[off])
+#define LAST_U8LE()  GET_U8LE(net_offset-1)
+#define LAST_U16LE() GET_U16LE(net_offset-2)
+#define LAST_U32LE() GET_U32LE(net_offset-4)
+#define LAST_U64LE() GET_U64LE(net_offset-8)
 
-LM_ALWAYS_INLINE static bool validate_fid(struct _validate_ctx *ctx) {
-	return validate_4(ctx);
-}
-
-LM_ALWAYS_INLINE static bool validate_s(struct _validate_ctx *ctx) {
-	uint16_t len;
-	return false
-	    || (validate_2(ctx) || ({ len = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || _validate_size_net(ctx, len)
-	    || ({ (!is_valid_utf8_without_nul(&ctx->net_bytes[ctx->net_offset-len], len)) && lib9p_error(ctx->ctx, LINUX_EBADMSG, "message contains invalid UTF-8"); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_dm(struct _validate_ctx *ctx) {
-	 if (validate_4(ctx))
-		return true;
-	lib9p_dm_t mask = dm_masks[ctx->ctx->version];
-	lib9p_dm_t val = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#04"PRIx32, val & ~mask);
-	return false;
+static ssize_t validate_stat(struct _validate_ctx *ctx, uint32_t *ret_net_size) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_stat);
+	uint32_t offsetof_stat_size = net_offset + 0;
+	uint32_t offsetof_kern_type = net_offset + 2;
+	uint32_t offsetof_file_qid_type = net_offset + 8;
+	VALIDATE_NET_BYTES(21);
+	if (GET_U8LE(offsetof_file_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_file_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_file_mode = net_offset + 0;
+	VALIDATE_NET_BYTES(22);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+#if CONFIG_9P_ENABLE_9P2000_u
+	if (is_ver(ctx, 9P2000_u)) {
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+		VALIDATE_NET_BYTES(12);
+	}
+#endif /* CONFIG_9P_ENABLE_9P2000_u */
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_stat_size) != (uint32_t)(offsetof_end - offsetof_kern_type))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "stat->stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_stat_size), (uint32_t)(offsetof_end - offsetof_kern_type));
+	if (GET_U32LE(offsetof_file_mode) & ~dm_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_file_mode) & ~dm_masks[ctx->ctx->version]);
+	if (ret_net_size)
+		*ret_net_size = net_offset;
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_qt(struct _validate_ctx *ctx) {
-	 if (validate_1(ctx))
-		return true;
-	lib9p_qt_t mask = qt_masks[ctx->ctx->version];
-	lib9p_qt_t val = ctx->net_bytes[ctx->net_offset-1];
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#01"PRIx8, val & ~mask);
-	return false;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
+static ssize_t validate_Tversion(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tversion);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(100))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(100));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rversion(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rversion);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(101))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(101));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tauth(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tauth);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
 #if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_nuid(struct _validate_ctx *ctx) {
-	return validate_4(ctx);
-}
-
+	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
+		VALIDATE_NET_BYTES(4);
+	}
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_o(struct _validate_ctx *ctx) {
-	 if (validate_1(ctx))
-		return true;
-	lib9p_o_t mask = o_masks[ctx->ctx->version];
-	lib9p_o_t val = ctx->net_bytes[ctx->net_offset-1];
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#01"PRIx8, val & ~mask);
-	return false;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(102))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(102));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rauth(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rauth);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_aqid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(103))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(103));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tattach(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tattach);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(17);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
 #if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_errno(struct _validate_ctx *ctx) {
-	return validate_4(ctx);
-}
-
+	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
+		VALIDATE_NET_BYTES(4);
+	}
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_ALWAYS_INLINE static bool validate_super_magic(struct _validate_ctx *ctx) {
-	return validate_4(ctx);
-}
-
-LM_ALWAYS_INLINE static bool validate_lo(struct _validate_ctx *ctx) {
-	 if (validate_4(ctx))
-		return true;
-	lib9p_lo_t mask = lo_masks[ctx->ctx->version];
-	lib9p_lo_t val = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in lo bitfield: %#04"PRIx32, val & ~mask);
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_dt(struct _validate_ctx *ctx) {
-	return validate_1(ctx);
-}
-
-LM_ALWAYS_INLINE static bool validate_mode(struct _validate_ctx *ctx) {
-	 if (validate_4(ctx))
-		return true;
-	lib9p_mode_t mask = mode_masks[ctx->ctx->version];
-	lib9p_mode_t val = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#04"PRIx32, val & ~mask);
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_b4(struct _validate_ctx *ctx) {
-	return validate_4(ctx);
-}
-
-LM_ALWAYS_INLINE static bool validate_getattr(struct _validate_ctx *ctx) {
-	 if (validate_8(ctx))
-		return true;
-	lib9p_getattr_t mask = getattr_masks[ctx->ctx->version];
-	lib9p_getattr_t val = uint64le_decode(&ctx->net_bytes[ctx->net_offset-8]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in getattr bitfield: %#08"PRIx64, val & ~mask);
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_setattr(struct _validate_ctx *ctx) {
-	 if (validate_4(ctx))
-		return true;
-	lib9p_setattr_t mask = setattr_masks[ctx->ctx->version];
-	lib9p_setattr_t val = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in setattr bitfield: %#04"PRIx32, val & ~mask);
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_lock_type(struct _validate_ctx *ctx) {
-	return validate_1(ctx);
-}
-
-LM_ALWAYS_INLINE static bool validate_lock_flags(struct _validate_ctx *ctx) {
-	 if (validate_4(ctx))
-		return true;
-	lib9p_lock_flags_t mask = lock_flags_masks[ctx->ctx->version];
-	lib9p_lock_flags_t val = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]);
-	if (val & ~mask)
-		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in lock_flags bitfield: %#04"PRIx32, val & ~mask);
-	return false;
-}
-
-LM_ALWAYS_INLINE static bool validate_lock_status(struct _validate_ctx *ctx) {
-	return validate_1(ctx);
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Tflush(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_2(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 108; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rflush(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 109; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rread(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || _validate_size_net(ctx, count)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 117; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint32_t max = INT32_MAX; (((uint32_t)count) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "count value is too large (%"PRIu32" > %"PRIu32")", count, max); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rwrite(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 119; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint32_t max = INT32_MAX; (((uint32_t)count) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "count value is too large (%"PRIu32" > %"PRIu32")", count, max); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rclunk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 121; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rremove(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 123; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Rwstat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 127; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Rrename(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 21; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rsetattr(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 27; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rxattrwalk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_8(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 31; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rxattrcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 33; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rreaddir(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || _validate_size_net(ctx, count)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 41; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rfsync(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 51; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 71; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rrenameat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 75; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Runlinkat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 77; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
-#if CONFIG_9P_ENABLE_9P2000_e
-LM_FLATTEN static bool validate_Tsession(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_8(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 150; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rsession(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 151; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rsread(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || _validate_size_net(ctx, count)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 153; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rswrite(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 155; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_e */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Tread(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint64_t offset;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || (validate_8(ctx) || ({ offset = uint64le_decode(&ctx->net_bytes[ctx->net_offset-8]); false; }))
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 116; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint64_t max = INT64_MAX; (((uint64_t)offset) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "offset value is too large (%"PRIu64" > %"PRIu64")", offset, max); })
-	    || ({ uint32_t max = INT32_MAX; (((uint32_t)count) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "count value is too large (%"PRIu32" > %"PRIu32")", count, max); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Twrite(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint64_t offset;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || (validate_8(ctx) || ({ offset = uint64le_decode(&ctx->net_bytes[ctx->net_offset-8]); false; }))
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || _validate_size_net(ctx, count)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 118; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint64_t max = INT64_MAX; (((uint64_t)offset) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "offset value is too large (%"PRIu64" > %"PRIu64")", offset, max); })
-	    || ({ uint32_t max = INT32_MAX; (((uint32_t)count) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "count value is too large (%"PRIu32" > %"PRIu32")", count, max); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tclunk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 120; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tremove(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 122; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(104))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(104));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rattach(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rattach);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(105))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(105));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rerror(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rerror);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(9);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+#if CONFIG_9P_ENABLE_9P2000_u
+	if (is_ver(ctx, 9P2000_u)) {
+		VALIDATE_NET_BYTES(4);
+	}
+#endif /* CONFIG_9P_ENABLE_9P2000_u */
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(107))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(107));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tflush(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tflush);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 9;
+	VALIDATE_NET_BYTES(9);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(108))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(108));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rflush(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rflush);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(109))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(109));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Twalk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Twalk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_nwname = net_offset + 15;
+	VALIDATE_NET_BYTES(17);
+	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
+		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+	}
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(110))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(110));
+	if ((uint16_t)GET_U16LE(offsetof_nwname) > (uint16_t)(16))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twalk->nwname value is too large: %"PRIu16" > %"PRIu16,
+			(uint16_t)GET_U16LE(offsetof_nwname), (uint16_t)(16));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rwalk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rwalk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_nwqid = net_offset + 7;
+	VALIDATE_NET_BYTES(9);
+	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
+		RESERVE_HOST_BYTES(sizeof(struct lib9p_qid));
+		uint32_t offsetof_wqid_type = net_offset + 0;
+		VALIDATE_NET_BYTES(13);
+		if (GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->ctx->version])
+			return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+				GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->ctx->version]);
+	}
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(111))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(111));
+	if ((uint16_t)GET_U16LE(offsetof_nwqid) > (uint16_t)(16))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwalk->nwqid value is too large: %"PRIu16" > %"PRIu16,
+			(uint16_t)GET_U16LE(offsetof_nwqid), (uint16_t)(16));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Tstat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 124; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
+static ssize_t validate_Topen(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Topen);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_mode = net_offset + 11;
+	uint32_t offsetof_end = net_offset + 12;
+	VALIDATE_NET_BYTES(12);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Topen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(112))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Topen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(112));
+	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Ropen(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Ropen);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Ropen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(113))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Ropen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(113));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_perm = net_offset + 0;
+	uint32_t offsetof_mode = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 5;
+	VALIDATE_NET_BYTES(5);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(114))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(114));
+	if (GET_U32LE(offsetof_perm) & ~dm_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_perm) & ~dm_masks[ctx->ctx->version]);
+	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(115))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(115));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Tstatfs(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 8; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Treadlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 22; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Treaddir(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 40; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Tversion(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_4(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 100; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rversion(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_4(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 101; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Twalk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nwname;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_fid(ctx)
-	    || (validate_2(ctx) || ({ nwname = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || _validate_list(ctx, nwname, validate_s, sizeof(struct lib9p_s))
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 110; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint16_t max = 16; (((uint16_t)nwname) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "nwname value is too large (%"PRIu16" > %"PRIu16")", nwname, max); })
-	    ;
+static ssize_t validate_Tread(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tread);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_offset = net_offset + 11;
+	uint32_t offsetof_count = net_offset + 19;
+	uint32_t offsetof_end = net_offset + 23;
+	VALIDATE_NET_BYTES(23);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(116))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(116));
+	if ((uint64_t)GET_U64LE(offsetof_offset) > (uint64_t)(INT64_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tread->offset value is too large: %"PRIu64" > %"PRIu64,
+			(uint64_t)GET_U64LE(offsetof_offset), (uint64_t)(INT64_MAX));
+	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tread->count value is too large: %"PRIu32" > %"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rread(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rread);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_count = net_offset + 7;
+	VALIDATE_NET_BYTES(11);
+	VALIDATE_NET_BYTES(LAST_U32LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(117))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(117));
+	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rread->count value is too large: %"PRIu32" > %"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Twrite(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Twrite);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_offset = net_offset + 11;
+	uint32_t offsetof_count = net_offset + 19;
+	VALIDATE_NET_BYTES(23);
+	VALIDATE_NET_BYTES(LAST_U32LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(118))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(118));
+	if ((uint64_t)GET_U64LE(offsetof_offset) > (uint64_t)(INT64_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twrite->offset value is too large: %"PRIu64" > %"PRIu64,
+			(uint64_t)GET_U64LE(offsetof_offset), (uint64_t)(INT64_MAX));
+	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twrite->count value is too large: %"PRIu32" > %"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rwrite(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rwrite);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_count = net_offset + 7;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(119))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(119));
+	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwrite->count value is too large: %"PRIu32" > %"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tclunk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tclunk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(120))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(120));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rclunk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rclunk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(121))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(121));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tremove(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tremove);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(122))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(122));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rremove(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rremove);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(123))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(123));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Trename(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 20; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rreadlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 23; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Txattrwalk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 30; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Txattrcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 32; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 70; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Trenameat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 74; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tunlinkat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 76; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
-#if CONFIG_9P_ENABLE_9P2000_e
-LM_FLATTEN static bool validate_Tsread(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nwname;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_4(ctx)
-	    || (validate_2(ctx) || ({ nwname = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || _validate_list(ctx, nwname, validate_s, sizeof(struct lib9p_s))
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 152; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tswrite(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nwname;
-	uint32_t count;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_4(ctx)
-	    || (validate_2(ctx) || ({ nwname = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || _validate_list(ctx, nwname, validate_s, sizeof(struct lib9p_s))
-	    || (validate_4(ctx) || ({ count = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || _validate_size_net(ctx, count)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 154; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_e */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_qid(struct _validate_ctx *ctx) {
-	return false
-	    || validate_qt(ctx)
-	    || validate_4(ctx)
-	    || validate_8(ctx)
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tauth(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
-#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
-	    || ( ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) && validate_nuid(ctx) )
-#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 102; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tattach(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
-#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
-	    || ( ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) && validate_nuid(ctx) )
-#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 104; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Tsymlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
-	    || validate_nuid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 16; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
 #if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Topen(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_o(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 112; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_dm(ctx)
-	    || validate_o(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 114; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_p9p
-LM_FLATTEN static bool validate_Topenfd(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_o(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 98; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Rerror(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_s(ctx)
+static ssize_t validate_Tstat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tstat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(124))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(124));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rstat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rstat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_nstat = net_offset + 7;
+	uint32_t offsetof_stat = net_offset + 9;
+	uint32_t offsetof_stat_stat_size = net_offset + 9;
+	uint32_t offsetof_stat_kern_type = net_offset + 11;
+	uint32_t offsetof_stat_file_qid_type = net_offset + 17;
+	VALIDATE_NET_BYTES(30);
+	if (GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_stat_file_mode = net_offset + 0;
+	VALIDATE_NET_BYTES(22);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
 #if CONFIG_9P_ENABLE_9P2000_u
-	    || ( is_ver(ctx, 9P2000_u) && validate_errno(ctx) )
+	if (is_ver(ctx, 9P2000_u)) {
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+		VALIDATE_NET_BYTES(12);
+	}
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 107; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Rlerror(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_errno(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 7; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rstatfs(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_super_magic(ctx)
-	    || validate_4(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 9; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tlopen(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_lo(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 12; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tlcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_lo(ctx)
-	    || validate_mode(ctx)
-	    || validate_nuid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 14; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tmknod(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_mode(ctx)
-	    || validate_4(ctx)
-	    || validate_4(ctx)
-	    || validate_nuid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 18; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tmkdir(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_s(ctx)
-	    || validate_mode(ctx)
-	    || validate_nuid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 72; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tfsync(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_b4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 50; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tgetattr(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_getattr(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 24; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tsetattr(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_setattr(ctx)
-	    || validate_mode(ctx)
-	    || validate_nuid(ctx)
-	    || validate_nuid(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 26; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tgetlock(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_lock_type(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 54; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rgetlock(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_lock_type(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 55; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Tlock(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || validate_lock_type(ctx)
-	    || validate_lock_flags(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_4(ctx)
-	    || validate_s(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 52; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rlock(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_lock_status(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 53; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000_L */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_ALWAYS_INLINE static bool validate_stat(struct _validate_ctx *ctx) {
-	uint16_t stat_size;
-	uint32_t _kern_type_offset;
-	return false
-	    || (validate_2(ctx) || ({ stat_size = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || ({ _kern_type_offset = ctx->net_offset; validate_2(ctx); })
-	    || validate_4(ctx)
-	    || validate_qid(ctx)
-	    || validate_dm(ctx)
-	    || validate_4(ctx)
-	    || validate_4(ctx)
-	    || validate_8(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
-	    || validate_s(ctx)
+	uint32_t offsetof_stat_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_stat_stat_size) != (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_stat_stat_size), (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type));
+	if (GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(125))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(125));
+	if ((uint32_t)GET_U32LE(offsetof_nstat) != (uint32_t)(offsetof_end - offsetof_stat))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_nstat), (uint32_t)(offsetof_end - offsetof_stat));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Twstat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Twstat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_nstat = net_offset + 11;
+	uint32_t offsetof_stat = net_offset + 13;
+	uint32_t offsetof_stat_stat_size = net_offset + 13;
+	uint32_t offsetof_stat_kern_type = net_offset + 15;
+	uint32_t offsetof_stat_file_qid_type = net_offset + 21;
+	VALIDATE_NET_BYTES(34);
+	if (GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_stat_file_mode = net_offset + 0;
+	VALIDATE_NET_BYTES(22);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
 #if CONFIG_9P_ENABLE_9P2000_u
-	    || ( is_ver(ctx, 9P2000_u) && validate_s(ctx) )
-	    || ( is_ver(ctx, 9P2000_u) && validate_nuid(ctx) )
-	    || ( is_ver(ctx, 9P2000_u) && validate_nuid(ctx) )
-	    || ( is_ver(ctx, 9P2000_u) && validate_nuid(ctx) )
+	if (is_ver(ctx, 9P2000_u)) {
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+		VALIDATE_NET_BYTES(12);
+	}
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
-	    || ({ uint16_t exp = ctx->net_offset - _kern_type_offset; (((uint16_t)stat_size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "stat_size value is wrong (actual:%"PRIu16" != correct:%"PRIu16")", (uint16_t)stat_size, exp); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Rauth(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 103; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rattach(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 105; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rwalk(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nwqid;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_2(ctx) || ({ nwqid = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || _validate_list(ctx, nwqid, validate_qid, sizeof(struct lib9p_qid))
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 111; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint16_t max = 16; (((uint16_t)nwqid) > max) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "nwqid value is too large (%"PRIu16" > %"PRIu16")", nwqid, max); })
-	    ;
-}
-
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Ropen(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 113; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 115; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
+	uint32_t offsetof_stat_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_stat_stat_size) != (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_stat_stat_size), (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type));
+	if (GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(126))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(126));
+	if ((uint32_t)GET_U32LE(offsetof_nstat) != (uint32_t)(offsetof_end - offsetof_stat))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Twstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_nstat), (uint32_t)(offsetof_end - offsetof_stat));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rwstat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rwstat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(127))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rwstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(127));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
 #if CONFIG_9P_ENABLE_9P2000_p9p
-LM_FLATTEN static bool validate_Ropenfd(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || validate_4(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 99; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
+static ssize_t validate_Topenfd(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Topenfd);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_mode = net_offset + 11;
+	uint32_t offsetof_end = net_offset + 12;
+	VALIDATE_NET_BYTES(12);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Topenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(98))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Topenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(98));
+	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_mode) & ~o_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Ropenfd(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Ropenfd);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 8;
+	VALIDATE_NET_BYTES(8);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Ropenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(99))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Ropenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(99));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000_p9p */
 #if CONFIG_9P_ENABLE_9P2000_L
-LM_FLATTEN static bool validate_Rlopen(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 13; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rlcreate(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || validate_4(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 15; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rsymlink(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 17; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rmknod(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 19; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rgetattr(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_getattr(ctx)
-	    || validate_qid(ctx)
-	    || validate_mode(ctx)
-	    || validate_nuid(ctx)
-	    || validate_nuid(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || validate_8(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 25; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Rmkdir(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint32_t _size_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_qid(ctx)
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 73; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    ;
+static ssize_t validate_Rlerror(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rlerror);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(7))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(7));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tstatfs(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tstatfs);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(8))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(8));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rstatfs(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rstatfs);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 67;
+	VALIDATE_NET_BYTES(67);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(9))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(9));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tlopen(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tlopen);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_flags = net_offset + 11;
+	uint32_t offsetof_end = net_offset + 15;
+	VALIDATE_NET_BYTES(15);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(12))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(12));
+	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_flags) & ~lo_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rlopen(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rlopen);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(13))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(13));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tlcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tlcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_flags = net_offset + 0;
+	uint32_t offsetof_mode = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 12;
+	VALIDATE_NET_BYTES(12);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(14))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(14));
+	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_flags) & ~lo_masks[ctx->ctx->version]);
+	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rlcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rlcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(15))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(15));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tsymlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tsymlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(2);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(16))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(16));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rsymlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rsymlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(17))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(17));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tmknod(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tmknod);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_mode = net_offset + 0;
+	uint32_t offsetof_end = net_offset + 16;
+	VALIDATE_NET_BYTES(16);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(18))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(18));
+	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rmknod(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rmknod);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(19))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(19));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Trename(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Trename);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(17);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Trename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(20))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Trename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(20));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rrename(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rrename);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rrename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(21))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rrename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(21));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Treadlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Treadlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Treadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(22))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Treadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(22));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rreadlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rreadlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(9);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rreadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(23))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rreadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(23));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tgetattr(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tgetattr);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_request_mask = net_offset + 11;
+	uint32_t offsetof_end = net_offset + 19;
+	VALIDATE_NET_BYTES(19);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(24))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(24));
+	if (GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
+			GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rgetattr(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rgetattr);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_valid = net_offset + 7;
+	uint32_t offsetof_qid_type = net_offset + 15;
+	VALIDATE_NET_BYTES(28);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_mode = net_offset + 0;
+	uint32_t offsetof_end = net_offset + 132;
+	VALIDATE_NET_BYTES(132);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(25))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(25));
+	if (GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
+			GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->ctx->version]);
+	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tsetattr(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tsetattr);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_valid = net_offset + 11;
+	uint32_t offsetof_mode = net_offset + 15;
+	uint32_t offsetof_end = net_offset + 67;
+	VALIDATE_NET_BYTES(67);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(26))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(26));
+	if (GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in setattr bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->ctx->version]);
+	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rsetattr(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rsetattr);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(27))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(27));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Txattrwalk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Txattrwalk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(17);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Txattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(30))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Txattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(30));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rxattrwalk(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rxattrwalk);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 15;
+	VALIDATE_NET_BYTES(15);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rxattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(31))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rxattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(31));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Txattrcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Txattrcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 12;
+	VALIDATE_NET_BYTES(12);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Txattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(32))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Txattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(32));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rxattrcreate(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rxattrcreate);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rxattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(33))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rxattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(33));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Treaddir(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Treaddir);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 23;
+	VALIDATE_NET_BYTES(23);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Treaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(40))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Treaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(40));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rreaddir(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rreaddir);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(11);
+	VALIDATE_NET_BYTES(LAST_U32LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rreaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(41))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rreaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(41));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tfsync(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tfsync);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 15;
+	VALIDATE_NET_BYTES(15);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(50))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(50));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rfsync(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rfsync);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(51))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(51));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tlock(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tlock);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_flags = net_offset + 12;
+	VALIDATE_NET_BYTES(38);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(52))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(52));
+	if (GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in lock_flags bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rlock(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rlock);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 8;
+	VALIDATE_NET_BYTES(8);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(53))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(53));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tgetlock(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tgetlock);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(34);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(54))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(54));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rgetlock(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rgetlock);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(30);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(55))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(55));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(17);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(70))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(70));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rlink(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rlink);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(71))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(71));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tmkdir(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tmkdir);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_mode = net_offset + 0;
+	uint32_t offsetof_end = net_offset + 8;
+	VALIDATE_NET_BYTES(8);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(72))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(72));
+	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->ctx->version]);
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rmkdir(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rmkdir);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_qid_type = net_offset + 7;
+	VALIDATE_NET_BYTES(20);
+	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version])
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->ctx->version]);
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(73))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(73));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Trenameat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Trenameat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	VALIDATE_NET_BYTES(6);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Trenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(74))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Trenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(74));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rrenameat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rrenameat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rrenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(75))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rrenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(75));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tunlinkat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tunlinkat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	VALIDATE_NET_UTF8(LAST_U16LE());
+	uint32_t offsetof_end = net_offset + 4;
+	VALIDATE_NET_BYTES(4);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tunlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(76))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tunlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(76));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Runlinkat(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Runlinkat);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Runlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(77))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Runlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(77));
+	return (ssize_t)host_size;
 }
 
 #endif /* CONFIG_9P_ENABLE_9P2000_L */
-#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
-LM_FLATTEN static bool validate_Rstat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nstat;
-	uint32_t _size_offset;
-	uint32_t _stat_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || (validate_2(ctx) || ({ nstat = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || ({ _stat_offset = ctx->net_offset; validate_stat(ctx); })
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 125; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint16_t exp = ctx->net_offset - _stat_offset; (((uint16_t)nstat) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "nstat value is wrong (actual:%"PRIu16" != correct:%"PRIu16")", (uint16_t)nstat, exp); })
-	    ;
-}
-
-LM_FLATTEN static bool validate_Twstat(struct _validate_ctx *ctx) {
-	uint32_t size;
-	uint8_t typ;
-	uint16_t nstat;
-	uint32_t _size_offset;
-	uint32_t _stat_offset;
-	return false
-	    || (({ _size_offset = ctx->net_offset; validate_4(ctx); }) || ({ size = uint32le_decode(&ctx->net_bytes[ctx->net_offset-4]); false; }))
-	    || (validate_1(ctx) || ({ typ = ctx->net_bytes[ctx->net_offset-1]; false; }))
-	    || validate_tag(ctx)
-	    || validate_fid(ctx)
-	    || (validate_2(ctx) || ({ nstat = uint16le_decode(&ctx->net_bytes[ctx->net_offset-2]); false; }))
-	    || ({ _stat_offset = ctx->net_offset; validate_stat(ctx); })
-	    || ({ uint32_t exp = ctx->net_offset - _size_offset; (((uint32_t)size) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "size value is wrong (actual:%"PRIu32" != correct:%"PRIu32")", (uint32_t)size, exp); })
-	    || ({ uint8_t exp = 126; (((uint8_t)typ) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "typ value is wrong (actual:%"PRIu8" != correct:%"PRIu8")", (uint8_t)typ, exp); })
-	    || ({ uint16_t exp = ctx->net_offset - _stat_offset; (((uint16_t)nstat) != exp) &&
-	          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "nstat value is wrong (actual:%"PRIu16" != correct:%"PRIu16")", (uint16_t)nstat, exp); })
-	    ;
+#if CONFIG_9P_ENABLE_9P2000_e
+static ssize_t validate_Tsession(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tsession);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 15;
+	VALIDATE_NET_BYTES(15);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(150))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(150));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rsession(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rsession);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 7;
+	VALIDATE_NET_BYTES(7);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(151))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(151));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tsread(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tsread);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
+		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+	}
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(152))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(152));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rsread(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rsread);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(11);
+	VALIDATE_NET_BYTES(LAST_U32LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(153))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(153));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Tswrite(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Tswrite);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	VALIDATE_NET_BYTES(13);
+	for (uint16_t i = 0, cnt = LAST_U16LE(); i < cnt; i++) {
+		RESERVE_HOST_BYTES(sizeof(struct lib9p_s));
+		VALIDATE_NET_BYTES(2);
+		VALIDATE_NET_UTF8(LAST_U16LE());
+	}
+	VALIDATE_NET_BYTES(4);
+	VALIDATE_NET_BYTES(LAST_U32LE());
+	uint32_t offsetof_end = net_offset + 0;
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(154))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Tswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(154));
+	return (ssize_t)host_size;
+}
+
+static ssize_t validate_Rswrite(struct _validate_ctx *ctx) {
+	uint32_t net_offset = 0;
+	ssize_t host_size = sizeof(struct lib9p_msg_Rswrite);
+	uint32_t offsetof_size = net_offset + 0;
+	uint32_t offsetof_typ = net_offset + 4;
+	uint32_t offsetof_end = net_offset + 11;
+	VALIDATE_NET_BYTES(11);
+	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
+	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(155))
+		return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "Rswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(155));
+	return (ssize_t)host_size;
 }
-#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */
+#endif /* CONFIG_9P_ENABLE_9P2000_e */
 
 /* unmarshal_* ****************************************************************/
 
@@ -5039,8 +5002,8 @@ const struct _lib9p_send_tentry _lib9p_table_Rmsg_send[LIB9P_VER_NUM][0x80] = {
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 };
 
-LM_FLATTEN bool _lib9p_stat_validate(struct _validate_ctx *ctx) {
-	return validate_stat(ctx);
+LM_FLATTEN ssize_t _lib9p_stat_validate(struct _validate_ctx *ctx, uint32_t *ret_net_size) {
+	return validate_stat(ctx, ret_net_size);
 }
 LM_FLATTEN void _lib9p_stat_unmarshal(struct _unmarshal_ctx *ctx, struct lib9p_stat *out) {
 	unmarshal_stat(ctx, out);
diff --git a/lib9p/internal.h b/lib9p/internal.h
index 801dc4c..4820f10 100644
--- a/lib9p/internal.h
+++ b/lib9p/internal.h
@@ -43,14 +43,8 @@ struct _validate_ctx {
 	struct lib9p_ctx        *ctx;
 	uint32_t                 net_size;
 	uint8_t                 *net_bytes;
-
-	/* output */
-	uint32_t                 net_offset;
-	/* Increment `host_extra` to pre-allocate space that is
-	 * "extra" beyond sizeof().  */
-	size_t                   host_extra;
 };
-typedef bool (*_validate_fn_t)(struct _validate_ctx *ctx);
+typedef ssize_t (*_validate_fn_t)(struct _validate_ctx *ctx);
 
 struct _unmarshal_ctx {
 	/* input */
@@ -96,7 +90,7 @@ extern const struct _lib9p_recv_tentry _lib9p_table_Rmsg_recv[LIB9P_VER_NUM][0x8
 extern const struct _lib9p_send_tentry _lib9p_table_Tmsg_send[LIB9P_VER_NUM][0x80];
 extern const struct _lib9p_send_tentry _lib9p_table_Rmsg_send[LIB9P_VER_NUM][0x80];
 
-bool _lib9p_stat_validate(struct _validate_ctx *ctx);
+ssize_t _lib9p_stat_validate(struct _validate_ctx *ctx, uint32_t *ret_net_size);
 void _lib9p_stat_unmarshal(struct _unmarshal_ctx *ctx, struct lib9p_stat *out);
 bool _lib9p_stat_marshal(struct _marshal_ctx *ctx, struct lib9p_stat *val);
 
diff --git a/lib9p/protogen/c.py b/lib9p/protogen/c.py
index a7e1773..0cc5815 100644
--- a/lib9p/protogen/c.py
+++ b/lib9p/protogen/c.py
@@ -185,8 +185,8 @@ const char *const {c9util.ident('_table_ver_name')}[{c9util.ver_enum('NUM')}] =
     )
 
     ret += f"""
-LM_FLATTEN bool {c9util.ident('_stat_validate')}(struct _validate_ctx *ctx) {{
-\treturn validate_stat(ctx);
+LM_FLATTEN ssize_t {c9util.ident('_stat_validate')}(struct _validate_ctx *ctx, uint32_t *ret_net_size) {{
+\treturn validate_stat(ctx, ret_net_size);
 }}
 LM_FLATTEN void {c9util.ident('_stat_unmarshal')}(struct _unmarshal_ctx *ctx, struct {c9util.ident('stat')} *out) {{
 \tunmarshal_stat(ctx, out);
diff --git a/lib9p/protogen/c9util.py b/lib9p/protogen/c9util.py
index f9c49fc..e7ad999 100644
--- a/lib9p/protogen/c9util.py
+++ b/lib9p/protogen/c9util.py
@@ -107,11 +107,3 @@ def idl_expr(expr: idl.Expr, lookup_sym: typing.Callable[[str], str]) -> str:
             case _:
                 assert False
     return " ".join(ret)
-
-
-def arg_used(arg: str) -> str:
-    return arg
-
-
-def arg_unused(arg: str) -> str:
-    return f"LM_UNUSED({arg})"
diff --git a/lib9p/protogen/c_validate.py b/lib9p/protogen/c_validate.py
index a3f4348..1630af2 100644
--- a/lib9p/protogen/c_validate.py
+++ b/lib9p/protogen/c_validate.py
@@ -3,6 +3,7 @@
 # Copyright (C) 2024-2025  Luke T. Shumaker <lukeshu@lukeshu.com>
 # SPDX-License-Identifier: AGPL-3.0-or-later
 
+import typing
 
 import idl
 
@@ -17,155 +18,272 @@ from . import c9util, cutil, idlutil
 __all__ = ["gen_c_validate"]
 
 
-def should_save_value(typ: idl.Struct, member: idl.StructMember) -> bool:
-    return bool(member.max or member.val or any(m.cnt == member for m in typ.members))
+def should_save_offset(parent: idl.Struct, child: idl.StructMember) -> bool:
+    if child.val or child.max or isinstance(child.typ, idl.Bitfield):
+        return True
+    for sibling in parent.members:
+        if sibling.val:
+            for tok in sibling.val.tokens:
+                if isinstance(tok, idl.ExprSym) and tok.symname == f"&{child.membname}":
+                    return True
+        if sibling.max:
+            for tok in sibling.max.tokens:
+                if isinstance(tok, idl.ExprSym) and tok.symname == f"&{child.membname}":
+                    return True
+    return False
+
+
+def should_save_end_offset(struct: idl.Struct) -> bool:
+    for memb in struct.members:
+        if memb.val:
+            for tok in memb.val.tokens:
+                if isinstance(tok, idl.ExprSym) and tok.symname == "end":
+                    return True
+        if memb.max:
+            for tok in memb.max.tokens:
+                if isinstance(tok, idl.ExprSym) and tok.symname == "end":
+                    return True
+    return False
 
 
 def gen_c_validate(versions: set[str], typs: list[idl.UserType]) -> str:
     ret = """
 /* validate_* *****************************************************************/
 
-LM_ALWAYS_INLINE static bool _validate_size_net(struct _validate_ctx *ctx, uint32_t n) {
-\tif (__builtin_add_overflow(ctx->net_offset, n, &ctx->net_offset))
-\t\t/* If needed-net-size overflowed uint32_t, then
-\t\t * there's no way that actual-net-size will live up to
-\t\t * that.  */
-\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-\tif (ctx->net_offset > ctx->net_size)
-\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-\treturn false;
-}
-
-LM_ALWAYS_INLINE static bool _validate_size_host(struct _validate_ctx *ctx, size_t n) {
-\tif (__builtin_add_overflow(ctx->host_extra, n, &ctx->host_extra))
-\t\t/* If needed-host-size overflowed size_t, then there's
-\t\t * no way that actual-net-size will live up to
-\t\t * that.  */
-\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");
-\treturn false;
-}
-
-LM_ALWAYS_INLINE static bool _validate_list(struct _validate_ctx *ctx,
-                                         size_t cnt,
-                                         _validate_fn_t item_fn, size_t item_host_size) {
-\tfor (size_t i = 0; i < cnt; i++)
-\t\tif (_validate_size_host(ctx, item_host_size) || item_fn(ctx))
-\t\t\treturn true;
-\treturn false;
-}
-
-LM_ALWAYS_INLINE static bool validate_1(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 1); }
-LM_ALWAYS_INLINE static bool validate_2(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 2); }
-LM_ALWAYS_INLINE static bool validate_4(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 4); }
-LM_ALWAYS_INLINE static bool validate_8(struct _validate_ctx *ctx) { return _validate_size_net(ctx, 8); }
 """
+    ret += cutil.macro(
+        "#define VALIDATE_NET_BYTES(n)\n"
+        "\tif (__builtin_add_overflow(net_offset, n, &net_offset))\n"
+        "\t\t/* If needed-net-size overflowed uint32_t, then\n"
+        "\t\t * there's no way that actual-net-size will live up to\n"
+        "\t\t * that.  */\n"
+        '\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");\n'
+        "\tif (net_offset > ctx->net_size)\n"
+        '\t\treturn lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "message is too short for content (%"PRIu32" > %"PRIu32") @ %d", net_offset, ctx->net_size, __LINE__);\n'
+    )
+    ret += cutil.macro(
+        "#define VALIDATE_NET_UTF8(n)\n"
+        "\t{\n"
+        "\t\tsize_t len = n;\n"
+        "\t\tVALIDATE_NET_BYTES(len);\n"
+        "\t\tif (!is_valid_utf8_without_nul(&ctx->net_bytes[net_offset-len], len))\n"
+        '\t\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message contains invalid UTF-8");\n'
+        "\t}\n"
+    )
+    ret += cutil.macro(
+        "#define RESERVE_HOST_BYTES(n)\n"
+        "\tif (__builtin_add_overflow(host_size, n, &host_size))\n"
+        "\t\t/* If needed-host-size overflowed ssize_t, then there's\n"
+        "\t\t * no way that actual-net-size will live up to\n"
+        "\t\t * that.  */\n"
+        '\t\treturn lib9p_error(ctx->ctx, LINUX_EBADMSG, "message is too short for content");\n'
+    )
+
+    ret += "#define GET_U8LE(off)  (ctx->net_bytes[off])\n"
+    ret += "#define GET_U16LE(off) uint16le_decode(&ctx->net_bytes[off])\n"
+    ret += "#define GET_U32LE(off) uint32le_decode(&ctx->net_bytes[off])\n"
+    ret += "#define GET_U64LE(off) uint64le_decode(&ctx->net_bytes[off])\n"
+
+    ret += "#define LAST_U8LE()  GET_U8LE(net_offset-1)\n"
+    ret += "#define LAST_U16LE() GET_U16LE(net_offset-2)\n"
+    ret += "#define LAST_U32LE() GET_U32LE(net_offset-4)\n"
+    ret += "#define LAST_U64LE() GET_U64LE(net_offset-8)\n"
+
+    class IndentLevel(typing.NamedTuple):
+        ifdef: bool  # whether this is both `{` and `#if`, or just `{`
+
+    indent_stack: list[IndentLevel]
+
+    def ifdef_lvl() -> int:
+        return sum(1 if lvl.ifdef else 0 for lvl in indent_stack)
+
+    def indent_lvl() -> int:
+        return len(indent_stack)
+
+    incr_buf: int
+
+    def incr_flush() -> None:
+        nonlocal ret
+        nonlocal incr_buf
+        if incr_buf:
+            ret += f"{'\t'*indent_lvl()}VALIDATE_NET_BYTES({incr_buf});\n"
+            incr_buf = 0
+
+    def gen_validate_size(path: idlutil.Path) -> None:
+        nonlocal ret
+        nonlocal incr_buf
+        nonlocal indent_stack
+
+        assert path.elems
+        child = path.elems[-1]
+        parent = path.elems[-2].typ if len(path.elems) > 1 else path.root
+        assert isinstance(parent, idl.Struct)
+
+        if child.in_versions < parent.in_versions:
+            if line := cutil.ifdef_push(
+                ifdef_lvl() + 1, c9util.ver_ifdef(child.in_versions)
+            ):
+                incr_flush()
+                ret += line
+                ret += (
+                    f"{'\t'*indent_lvl()}if ({c9util.ver_cond(child.in_versions)}) {{\n"
+                )
+                indent_stack.append(IndentLevel(ifdef=True))
+        if should_save_offset(parent, child):
+            ret += f"{'\t'*indent_lvl()}uint32_t offsetof{''.join('_'+m.membname for m in path.elems)} = net_offset + {incr_buf};\n"
+        if child.cnt:
+            assert child.cnt.typ.static_size
+            cnt_path = path.parent().add(child.cnt)
+            incr_flush()
+            if child.membname == "utf8":  # SPECIAL (string)
+                # Yes, this is content-validation and "belongs" in
+                # gen_validate_content(), not here.  But it's just
+                # easier this way.
+                ret += f"{'\t'*indent_lvl()}VALIDATE_NET_UTF8(LAST_U{child.cnt.typ.static_size*8}LE());\n"
+                return
+            if child.typ.static_size == 1:  # SPECIAL (zerocopy)
+                ret += f"{'\t'*indent_lvl()}VALIDATE_NET_BYTES(LAST_U{child.cnt.typ.static_size*8}LE());\n"
+                return
+            loopdepth = sum(1 for elem in path.elems if elem.cnt)
+            loopvar = chr(ord("i") + loopdepth - 1)
+            ret += f"{'\t'*indent_lvl()}for ({c9util.typename(child.cnt.typ)} {loopvar} = 0, cnt = LAST_U{child.cnt.typ.static_size*8}LE(); {loopvar} < cnt; {loopvar}++) {{\n"
+            indent_stack.append(IndentLevel(ifdef=False))
+            ret += f"{'\t'*indent_lvl()}RESERVE_HOST_BYTES(sizeof({c9util.typename(child.typ)}));\n"
+        if not isinstance(child.typ, idl.Struct):
+            incr_buf += child.typ.static_size
 
-    for typ in idlutil.topo_sorted(typs):
-        inline = "LM_FLATTEN" if isinstance(typ, idl.Message) else "LM_ALWAYS_INLINE"
-        argfn = (
-            c9util.arg_unused
-            if (isinstance(typ, idl.Struct) and not typ.members)
-            else c9util.arg_used
-        )
+    def gen_validate_content(path: idlutil.Path) -> None:
+        nonlocal ret
+        nonlocal incr_buf
+        nonlocal indent_stack
+
+        assert path.elems
+        child = path.elems[-1]
+        parent = path.elems[-2].typ if len(path.elems) > 1 else path.root
+        assert isinstance(parent, idl.Struct)
+
+        def lookup_sym(sym: str) -> str:
+            if sym.startswith("&"):
+                sym = sym[1:]
+            return f"offsetof{''.join('_'+m.membname for m in path.elems[:-1])}_{sym}"
+
+        if child.val:
+            incr_flush()
+            assert child.typ.static_size
+            nbits = child.typ.static_size * 8
+            nbits = child.typ.static_size * 8
+            if nbits < 32 and any(
+                isinstance(tok, idl.ExprSym)
+                and (tok.symname == "end" or tok.symname.startswith("&"))
+                for tok in child.val.tokens
+            ):
+                nbits = 32
+            act = f"(uint{nbits}_t)GET_U{nbits}LE({lookup_sym(f'&{child.membname}')})"
+            exp = f"(uint{nbits}_t)({c9util.idl_expr(child.val, lookup_sym)})"
+            ret += f"{'\t'*indent_lvl()}if ({act} != {exp})\n"
+            ret += f'{"\t"*(indent_lvl()+1)}return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "{path} value is wrong: actual: %"PRIu{nbits}" != correct:%"PRIu{nbits},\n'
+            ret += f"{'\t'*(indent_lvl()+2)}{act}, {exp});\n"
+        if child.max:
+            incr_flush()
+            assert child.typ.static_size
+            nbits = child.typ.static_size * 8
+            if nbits < 32 and any(
+                isinstance(tok, idl.ExprSym)
+                and (tok.symname == "end" or tok.symname.startswith("&"))
+                for tok in child.max.tokens
+            ):
+                nbits = 32
+            act = f"(uint{nbits}_t)GET_U{nbits}LE({lookup_sym(f'&{child.membname}')})"
+            exp = f"(uint{nbits}_t)({c9util.idl_expr(child.max, lookup_sym)})"
+            ret += f"{'\t'*indent_lvl()}if ({act} > {exp})\n"
+            ret += f'{"\t"*(indent_lvl()+1)}return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "{path} value is too large: %"PRIu{nbits}" > %"PRIu{nbits},\n'
+            ret += f"{'\t'*(indent_lvl()+2)}{act}, {exp});\n"
+        if isinstance(child.typ, idl.Bitfield):
+            incr_flush()
+            nbytes = child.typ.static_size
+            nbits = nbytes * 8
+            act = f"GET_U{nbits}LE({lookup_sym(f'&{child.membname}')})"
+            ret += f"{'\t'*indent_lvl()}if ({act} & ~{child.typ.typname}_masks[ctx->ctx->version])\n"
+            ret += f'{"\t"*(indent_lvl()+1)}return lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in {child.typ.typname} bitfield: %#0{nbytes*2}"PRIx{nbits},\n'
+            ret += f"{'\t'*(indent_lvl()+2)}{act} & ~{child.typ.typname}_masks[ctx->ctx->version]);\n"
+
+    def handle(
+        path: idlutil.Path,
+    ) -> tuple[idlutil.WalkCmd, typing.Callable[[], None]]:
+        nonlocal ret
+        nonlocal incr_buf
+        nonlocal indent_stack
+        indent_stack_len = len(indent_stack)
+        pop_struct = path.elems[-1].typ if path.elems else path.root
+        pop_path = path
+        pop_indent_stack_len: int
+
+        def pop() -> None:
+            nonlocal ret
+            nonlocal indent_stack
+            nonlocal indent_stack_len
+            nonlocal pop_struct
+            nonlocal pop_path
+            nonlocal pop_indent_stack_len
+            if isinstance(pop_struct, idl.Struct):
+                while len(indent_stack) > pop_indent_stack_len:
+                    incr_flush()
+                    ret += f"{'\t'*(indent_lvl()-1)}}}\n"
+                    if indent_stack.pop().ifdef:
+                        ret += cutil.ifdef_pop(ifdef_lvl())
+                parent = pop_struct
+                path = pop_path
+                if should_save_end_offset(parent):
+                    ret += f"{'\t'*indent_lvl()}uint32_t offsetof{''.join('_'+m.membname for m in path.elems)}_end = net_offset + {incr_buf};\n"
+                for child in parent.members:
+                    gen_validate_content(pop_path.add(child))
+            while len(indent_stack) > indent_stack_len:
+                if len(indent_stack) == indent_stack_len + 1 and indent_stack[-1].ifdef:
+                    break
+                incr_flush()
+                ret += f"{'\t'*(indent_lvl()-1)}}}\n"
+                if indent_stack.pop().ifdef:
+                    ret += cutil.ifdef_pop(ifdef_lvl())
+
+        if path.elems:
+            gen_validate_size(path)
+
+        pop_indent_stack_len = len(indent_stack)
+
+        return idlutil.WalkCmd.KEEP_GOING, pop
+
+    for typ in typs:
+        if not (
+            isinstance(typ, idl.Message) or typ.typname == "stat"
+        ):  # SPECIAL (include stat)
+            continue
+        assert isinstance(typ, idl.Struct)
         ret += "\n"
         ret += cutil.ifdef_push(1, c9util.ver_ifdef(typ.in_versions))
-        ret += f"{inline} static bool validate_{typ.typname}(struct _validate_ctx *{argfn('ctx')}) {{\n"
-
-        match typ:
-            case idl.Number():
-                ret += f"\treturn validate_{typ.prim.typname}(ctx);\n"
-            case idl.Bitfield():
-                ret += f"\t if (validate_{typ.static_size}(ctx))\n"
-                ret += "\t\treturn true;\n"
-                ret += f"\t{c9util.typename(typ)} mask = {typ.typname}_masks[ctx->ctx->version];\n"
-                if typ.static_size == 1:
-                    ret += f"\t{c9util.typename(typ)} val = ctx->net_bytes[ctx->net_offset-1];\n"
-                else:
-                    ret += f"\t{c9util.typename(typ)} val = uint{typ.static_size*8}le_decode(&ctx->net_bytes[ctx->net_offset-{typ.static_size}]);\n"
-                ret += "\tif (val & ~mask)\n"
-                ret += f'\t\treturn lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "unknown bits in {typ.typname} bitfield: %#0{typ.static_size}"PRIx{typ.static_size*8}, val & ~mask);\n'
-                ret += "\treturn false;\n"
-            case idl.Struct():  # and idl.Message()
-                if len(typ.members) == 0:
-                    ret += "\treturn false;\n"
-                    ret += "}\n"
-                    continue
-
-                # Pass 1 - declare value variables
-                for member in typ.members:
-                    if should_save_value(typ, member):
-                        ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
-                        ret += f"\t{c9util.typename(member.typ)} {member.membname};\n"
-                ret += cutil.ifdef_pop(1)
-
-                # Pass 2 - declare offset variables
-                mark_offset: set[str] = set()
-                for member in typ.members:
-                    for tok in [*member.max.tokens, *member.val.tokens]:
-                        if isinstance(tok, idl.ExprSym) and tok.symname.startswith("&"):
-                            if tok.symname[1:] not in mark_offset:
-                                ret += f"\tuint32_t _{tok.symname[1:]}_offset;\n"
-                            mark_offset.add(tok.symname[1:])
-
-                # Pass 3 - main pass
-                ret += "\treturn false\n"
-                for member in typ.members:
-                    ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
-                    ret += "\t    || "
-                    if member.in_versions != typ.in_versions:
-                        ret += "( " + c9util.ver_cond(member.in_versions) + " && "
-                    if member.cnt is not None:
-                        if member.typ.static_size == 1:  # SPECIAL (zerocopy)
-                            ret += f"_validate_size_net(ctx, {member.cnt.membname})"
-                        else:
-                            ret += f"_validate_list(ctx, {member.cnt.membname}, validate_{member.typ.typname}, sizeof({c9util.typename(member.typ)}))"
-                        if typ.typname == "s":  # SPECIAL (string)
-                            ret += '\n\t    || ({ (!is_valid_utf8_without_nul(&ctx->net_bytes[ctx->net_offset-len], len)) && lib9p_error(ctx->ctx, LINUX_EBADMSG, "message contains invalid UTF-8"); })'
-                    else:
-                        if should_save_value(typ, member):
-                            ret += "("
-                        if member.membname in mark_offset:
-                            ret += f"({{ _{member.membname}_offset = ctx->net_offset; "
-                        ret += f"validate_{member.typ.typname}(ctx)"
-                        if member.membname in mark_offset:
-                            ret += "; })"
-                        if should_save_value(typ, member):
-                            nbytes = member.static_size
-                            assert nbytes
-                            if nbytes == 1:
-                                ret += f" || ({{ {member.membname} = ctx->net_bytes[ctx->net_offset-1]; false; }}))"
-                            else:
-                                ret += f" || ({{ {member.membname} = uint{nbytes*8}le_decode(&ctx->net_bytes[ctx->net_offset-{nbytes}]); false; }}))"
-                    if member.in_versions != typ.in_versions:
-                        ret += " )"
-                    ret += "\n"
-
-                # Pass 4 - validate ,max= and ,val= constraints
-                for member in typ.members:
-
-                    def lookup_sym(sym: str) -> str:
-                        match sym:
-                            case "end":
-                                return "ctx->net_offset"
-                            case _:
-                                assert sym.startswith("&")
-                                return f"_{sym[1:]}_offset"
-
-                    if member.max:
-                        assert member.static_size
-                        nbits = member.static_size * 8
-                        ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
-                        ret += f"\t    || ({{ uint{nbits}_t max = {c9util.idl_expr(member.max, lookup_sym)}; (((uint{nbits}_t){member.membname}) > max) &&\n"
-                        ret += f'\t          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "{member.membname} value is too large (%"PRIu{nbits}" > %"PRIu{nbits}")", {member.membname}, max); }})\n'
-                    if member.val:
-                        assert member.static_size
-                        nbits = member.static_size * 8
-                        ret += cutil.ifdef_push(2, c9util.ver_ifdef(member.in_versions))
-                        ret += f"\t    || ({{ uint{nbits}_t exp = {c9util.idl_expr(member.val, lookup_sym)}; (((uint{nbits}_t){member.membname}) != exp) &&\n"
-                        ret += f'\t          lib9p_errorf(ctx->ctx, LINUX_EBADMSG, "{member.membname} value is wrong (actual:%"PRIu{nbits}" != correct:%"PRIu{nbits}")", (uint{nbits}_t){member.membname}, exp); }})\n'
-
-                ret += cutil.ifdef_pop(1)
-                ret += "\t    ;\n"
+        if typ.typname == "stat":  # SPECIAL (stat)
+            ret += f"static ssize_t validate_{typ.typname}(struct _validate_ctx *ctx, uint32_t *ret_net_size) {{\n"
+        else:
+            ret += (
+                f"static ssize_t validate_{typ.typname}(struct _validate_ctx *ctx) {{\n"
+            )
+
+        ret += "\tuint32_t net_offset = 0;\n"
+        ret += f"\tssize_t host_size = sizeof({c9util.typename(typ)});\n"
+
+        incr_buf = 0
+        indent_stack = [IndentLevel(ifdef=True)]
+        idlutil.walk(typ, handle)
+        while len(indent_stack) > 1:
+            incr_flush()
+            ret += f"{'\t'*(indent_lvl()-1)}}}\n"
+            if indent_stack.pop().ifdef:
+                ret += cutil.ifdef_pop(ifdef_lvl())
+
+        incr_flush()
+        if typ.typname == "stat":  # SPECIAL (stat)
+            ret += "\tif (ret_net_size)\n"
+            ret += "\t\t*ret_net_size = net_offset;\n"
+        ret += "\treturn (ssize_t)host_size;\n"
         ret += "}\n"
     ret += cutil.ifdef_pop(0)
     return ret