/* Generated by `lib9p/idl.gen lib9p/idl/2002-9P2000.9p lib9p/idl/2003-9P2000.p9p.9p lib9p/idl/2005-9P2000.u.9p lib9p/idl/2010-9P2000.L.9p lib9p/idl/2012-9P2000.e.9p`.  DO NOT EDIT!  */

#include <stdbool.h>
#include <stddef.h>   /* for size_t */
#include <inttypes.h> /* for PRI* macros */
#include <string.h>   /* for memset() */

#include <libmisc/assert.h>

#include <lib9p/9p.h>

#include "internal.h"

/* utilities ******************************************************************/
#if CONFIG_9P_ENABLE_9P2000
	#define _is_ver_9P2000(v) (v == LIB9P_VER_9P2000)
#else
	#define _is_ver_9P2000(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_L
	#define _is_ver_9P2000_L(v) (v == LIB9P_VER_9P2000_L)
#else
	#define _is_ver_9P2000_L(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_e
	#define _is_ver_9P2000_e(v) (v == LIB9P_VER_9P2000_e)
#else
	#define _is_ver_9P2000_e(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_p9p
	#define _is_ver_9P2000_p9p(v) (v == LIB9P_VER_9P2000_p9p)
#else
	#define _is_ver_9P2000_p9p(v) false
#endif
#if CONFIG_9P_ENABLE_9P2000_u
	#define _is_ver_9P2000_u(v) (v == LIB9P_VER_9P2000_u)
#else
	#define _is_ver_9P2000_u(v) false
#endif

/**
 * is_ver(ctx, ver) is essentially `(ctx->ctx->version == LIB9P_VER_##ver)`,
 * but compiles correctly (to `false`) even if `LIB9P_VER_##ver` isn't defined
 * (because `!CONFIG_9P_ENABLE_##ver`).  This is useful when `||`ing
 * several version checks together.
 */
#define is_ver(CTX, ver) _is_ver_##ver(CTX->ctx->version)

/* strings ********************************************************************/

const char *const _lib9p_table_ver_name[LIB9P_VER_NUM] = {
	[LIB9P_VER_unknown] = "unknown",
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = "9P2000",
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = "9P2000.L",
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = "9P2000.e",
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = "9P2000.p9p",
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = "9P2000.u",
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

#define _MSG_NAME(typ) [LIB9P_TYP_##typ] = #typ
const char *const _lib9p_table_msg_name[LIB9P_VER_NUM][0x100] = {
	[LIB9P_VER_unknown] = {
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Rerror),
	},
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Tauth),
		_MSG_NAME(Rauth),
		_MSG_NAME(Tattach),
		_MSG_NAME(Rattach),
		_MSG_NAME(Rerror),
		_MSG_NAME(Tflush),
		_MSG_NAME(Rflush),
		_MSG_NAME(Twalk),
		_MSG_NAME(Rwalk),
		_MSG_NAME(Topen),
		_MSG_NAME(Ropen),
		_MSG_NAME(Tcreate),
		_MSG_NAME(Rcreate),
		_MSG_NAME(Tread),
		_MSG_NAME(Rread),
		_MSG_NAME(Twrite),
		_MSG_NAME(Rwrite),
		_MSG_NAME(Tclunk),
		_MSG_NAME(Rclunk),
		_MSG_NAME(Tremove),
		_MSG_NAME(Rremove),
		_MSG_NAME(Tstat),
		_MSG_NAME(Rstat),
		_MSG_NAME(Twstat),
		_MSG_NAME(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_NAME(Rlerror),
		_MSG_NAME(Tstatfs),
		_MSG_NAME(Rstatfs),
		_MSG_NAME(Tlopen),
		_MSG_NAME(Rlopen),
		_MSG_NAME(Tlcreate),
		_MSG_NAME(Rlcreate),
		_MSG_NAME(Tsymlink),
		_MSG_NAME(Rsymlink),
		_MSG_NAME(Tmknod),
		_MSG_NAME(Rmknod),
		_MSG_NAME(Trename),
		_MSG_NAME(Rrename),
		_MSG_NAME(Treadlink),
		_MSG_NAME(Rreadlink),
		_MSG_NAME(Tgetattr),
		_MSG_NAME(Rgetattr),
		_MSG_NAME(Tsetattr),
		_MSG_NAME(Rsetattr),
		_MSG_NAME(Txattrwalk),
		_MSG_NAME(Rxattrwalk),
		_MSG_NAME(Txattrcreate),
		_MSG_NAME(Rxattrcreate),
		_MSG_NAME(Treaddir),
		_MSG_NAME(Rreaddir),
		_MSG_NAME(Tfsync),
		_MSG_NAME(Rfsync),
		_MSG_NAME(Tlock),
		_MSG_NAME(Rlock),
		_MSG_NAME(Tgetlock),
		_MSG_NAME(Rgetlock),
		_MSG_NAME(Tlink),
		_MSG_NAME(Rlink),
		_MSG_NAME(Tmkdir),
		_MSG_NAME(Rmkdir),
		_MSG_NAME(Trenameat),
		_MSG_NAME(Rrenameat),
		_MSG_NAME(Tunlinkat),
		_MSG_NAME(Runlinkat),
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Tauth),
		_MSG_NAME(Rauth),
		_MSG_NAME(Tattach),
		_MSG_NAME(Rattach),
		_MSG_NAME(Rerror),
		_MSG_NAME(Tflush),
		_MSG_NAME(Rflush),
		_MSG_NAME(Twalk),
		_MSG_NAME(Rwalk),
		_MSG_NAME(Tread),
		_MSG_NAME(Rread),
		_MSG_NAME(Twrite),
		_MSG_NAME(Rwrite),
		_MSG_NAME(Tclunk),
		_MSG_NAME(Rclunk),
		_MSG_NAME(Tremove),
		_MSG_NAME(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Tauth),
		_MSG_NAME(Rauth),
		_MSG_NAME(Tattach),
		_MSG_NAME(Rattach),
		_MSG_NAME(Rerror),
		_MSG_NAME(Tflush),
		_MSG_NAME(Rflush),
		_MSG_NAME(Twalk),
		_MSG_NAME(Rwalk),
		_MSG_NAME(Topen),
		_MSG_NAME(Ropen),
		_MSG_NAME(Tcreate),
		_MSG_NAME(Rcreate),
		_MSG_NAME(Tread),
		_MSG_NAME(Rread),
		_MSG_NAME(Twrite),
		_MSG_NAME(Rwrite),
		_MSG_NAME(Tclunk),
		_MSG_NAME(Rclunk),
		_MSG_NAME(Tremove),
		_MSG_NAME(Rremove),
		_MSG_NAME(Tstat),
		_MSG_NAME(Rstat),
		_MSG_NAME(Twstat),
		_MSG_NAME(Rwstat),
		_MSG_NAME(Tsession),
		_MSG_NAME(Rsession),
		_MSG_NAME(Tsread),
		_MSG_NAME(Rsread),
		_MSG_NAME(Tswrite),
		_MSG_NAME(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_NAME(Topenfd),
		_MSG_NAME(Ropenfd),
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Tauth),
		_MSG_NAME(Rauth),
		_MSG_NAME(Tattach),
		_MSG_NAME(Rattach),
		_MSG_NAME(Rerror),
		_MSG_NAME(Tflush),
		_MSG_NAME(Rflush),
		_MSG_NAME(Twalk),
		_MSG_NAME(Rwalk),
		_MSG_NAME(Topen),
		_MSG_NAME(Ropen),
		_MSG_NAME(Tcreate),
		_MSG_NAME(Rcreate),
		_MSG_NAME(Tread),
		_MSG_NAME(Rread),
		_MSG_NAME(Twrite),
		_MSG_NAME(Rwrite),
		_MSG_NAME(Tclunk),
		_MSG_NAME(Rclunk),
		_MSG_NAME(Tremove),
		_MSG_NAME(Rremove),
		_MSG_NAME(Tstat),
		_MSG_NAME(Rstat),
		_MSG_NAME(Twstat),
		_MSG_NAME(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_NAME(Tversion),
		_MSG_NAME(Rversion),
		_MSG_NAME(Tauth),
		_MSG_NAME(Rauth),
		_MSG_NAME(Tattach),
		_MSG_NAME(Rattach),
		_MSG_NAME(Rerror),
		_MSG_NAME(Tflush),
		_MSG_NAME(Rflush),
		_MSG_NAME(Twalk),
		_MSG_NAME(Rwalk),
		_MSG_NAME(Topen),
		_MSG_NAME(Ropen),
		_MSG_NAME(Tcreate),
		_MSG_NAME(Rcreate),
		_MSG_NAME(Tread),
		_MSG_NAME(Rread),
		_MSG_NAME(Twrite),
		_MSG_NAME(Rwrite),
		_MSG_NAME(Tclunk),
		_MSG_NAME(Rclunk),
		_MSG_NAME(Tremove),
		_MSG_NAME(Rremove),
		_MSG_NAME(Tstat),
		_MSG_NAME(Rstat),
		_MSG_NAME(Twstat),
		_MSG_NAME(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

/* bitmasks *******************************************************************/

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static const lib9p_dm_t dm_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b11101100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]   = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b11101100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b11101100000000000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b11101100101111000000000111111111,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

#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
static const lib9p_qt_t qt_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b11101100,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]   = 0b11101100,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b11101100,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b11101100,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b11101110,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

#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
static const lib9p_o_t o_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L]   = 0b00000000,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b01010011,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

#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
static const lib9p_getattr_t getattr_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]   = 0b0000000000000000000000000000000000000000000000000011111111111111,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b0000000000000000000000000000000000000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

static const lib9p_setattr_t setattr_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]   = 0b00000000000000000000000111111111,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

static const lib9p_lock_flags_t lock_flags_masks[LIB9P_VER_NUM] = {
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000]     = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000 */
	[LIB9P_VER_9P2000_L]   = 0b00000000000000000000000000000011,
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e]   = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u]   = 0b00000000000000000000000000000000,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};
#endif /* CONFIG_9P_ENABLE_9P2000_L */

/* 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.  */
		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);
}

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;
}

#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 */
#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);
}

#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 */
#if CONFIG_9P_ENABLE_9P2000_L
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_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_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 = 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_4(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_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); })
	    ;
}

#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); })
	    ;
}

#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_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_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 = 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_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); })
	    ;
}

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_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 = 50; (((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_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)
#if CONFIG_9P_ENABLE_9P2000_u
	    || ( is_ver(ctx, 9P2000_u) && validate_4(ctx) )
#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); })
	    ;
}

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); })
	    ;
}

#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_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_1(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_1(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_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_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_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 = 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_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); })
	    ;
}

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_4(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_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 = 72; (((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_L
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_4(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_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)
#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) )
#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); })
	    ;
}

#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); })
	    ;
}

#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_8(ctx)
	    || validate_qid(ctx)
	    || validate_4(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); })
	    ;
}

#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); })
	    ;
}
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */

/* unmarshal_* ****************************************************************/

LM_ALWAYS_INLINE static void unmarshal_1(struct _unmarshal_ctx *ctx, uint8_t *out) {
	*out = ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += 1;
}

LM_ALWAYS_INLINE static void unmarshal_2(struct _unmarshal_ctx *ctx, uint16_t *out) {
	*out = uint16le_decode(&ctx->net_bytes[ctx->net_offset]);
	ctx->net_offset += 2;
}

LM_ALWAYS_INLINE static void unmarshal_4(struct _unmarshal_ctx *ctx, uint32_t *out) {
	*out = uint32le_decode(&ctx->net_bytes[ctx->net_offset]);
	ctx->net_offset += 4;
}

LM_ALWAYS_INLINE static void unmarshal_8(struct _unmarshal_ctx *ctx, uint64_t *out) {
	*out = uint64le_decode(&ctx->net_bytes[ctx->net_offset]);
	ctx->net_offset += 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 void unmarshal_tag(struct _unmarshal_ctx *ctx, lib9p_tag_t *out) {
	unmarshal_2(ctx, (uint16_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_fid(struct _unmarshal_ctx *ctx, lib9p_fid_t *out) {
	unmarshal_4(ctx, (uint32_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_s(struct _unmarshal_ctx *ctx, struct lib9p_s *out) {
	memset(out, 0, sizeof(*out));
	unmarshal_2(ctx, &out->len);
	out->utf8 = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->len;
}

#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 void unmarshal_dm(struct _unmarshal_ctx *ctx, lib9p_dm_t *out) {
	unmarshal_4(ctx, (uint32_t *)out);
}

#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 void unmarshal_qt(struct _unmarshal_ctx *ctx, lib9p_qt_t *out) {
	unmarshal_1(ctx, (uint8_t *)out);
}

#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 || CONFIG_9P_ENABLE_9P2000_u
LM_ALWAYS_INLINE static void unmarshal_nuid(struct _unmarshal_ctx *ctx, lib9p_nuid_t *out) {
	unmarshal_4(ctx, (uint32_t *)out);
}

#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 void unmarshal_o(struct _unmarshal_ctx *ctx, lib9p_o_t *out) {
	unmarshal_1(ctx, (uint8_t *)out);
}

#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_ALWAYS_INLINE static void unmarshal_getattr(struct _unmarshal_ctx *ctx, lib9p_getattr_t *out) {
	unmarshal_8(ctx, (uint64_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_setattr(struct _unmarshal_ctx *ctx, lib9p_setattr_t *out) {
	unmarshal_4(ctx, (uint32_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_lock_type(struct _unmarshal_ctx *ctx, lib9p_lock_type_t *out) {
	unmarshal_1(ctx, (uint8_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_lock_flags(struct _unmarshal_ctx *ctx, lib9p_lock_flags_t *out) {
	unmarshal_4(ctx, (uint32_t *)out);
}

LM_ALWAYS_INLINE static void unmarshal_lock_status(struct _unmarshal_ctx *ctx, lib9p_lock_status_t *out) {
	unmarshal_1(ctx, (uint8_t *)out);
}

#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 void unmarshal_Tflush(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tflush *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_2(ctx, &out->oldtag);
}

LM_FLATTEN static void unmarshal_Rflush(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rflush *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rread(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rread *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->count);
	out->data = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->count;
}

LM_FLATTEN static void unmarshal_Rwrite(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rwrite *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->count);
}

LM_FLATTEN static void unmarshal_Rclunk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rclunk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rremove(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rremove *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

#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 void unmarshal_Rwstat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rwstat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

#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 void unmarshal_Rlerror(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rlerror *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->ecode);
}

LM_FLATTEN static void unmarshal_Rstatfs(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rstatfs *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->type);
	unmarshal_4(ctx, &out->bsize);
	unmarshal_8(ctx, &out->blocks);
	unmarshal_8(ctx, &out->bfree);
	unmarshal_8(ctx, &out->bavail);
	unmarshal_8(ctx, &out->files);
	unmarshal_8(ctx, &out->ffree);
	unmarshal_8(ctx, &out->fsid);
	unmarshal_4(ctx, &out->namelen);
}

LM_FLATTEN static void unmarshal_Rrename(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rrename *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rsetattr(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rsetattr *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rxattrwalk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rxattrwalk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_8(ctx, &out->attr_size);
}

LM_FLATTEN static void unmarshal_Rxattrcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rxattrcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rreaddir(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rreaddir *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->count);
	out->data = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->count;
}

LM_FLATTEN static void unmarshal_Rfsync(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rfsync *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rrenameat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rrenameat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Runlinkat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Runlinkat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
LM_FLATTEN static void unmarshal_Tsession(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tsession *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_8(ctx, &out->key);
}

LM_FLATTEN static void unmarshal_Rsession(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rsession *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
}

LM_FLATTEN static void unmarshal_Rsread(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rsread *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->count);
	out->data = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->count;
}

LM_FLATTEN static void unmarshal_Rswrite(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rswrite *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->count);
}

#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 void unmarshal_Tread(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tread *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_8(ctx, &out->offset);
	unmarshal_4(ctx, &out->count);
}

LM_FLATTEN static void unmarshal_Twrite(struct _unmarshal_ctx *ctx, struct lib9p_msg_Twrite *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_8(ctx, &out->offset);
	unmarshal_4(ctx, &out->count);
	out->data = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->count;
}

LM_FLATTEN static void unmarshal_Tclunk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tclunk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
}

LM_FLATTEN static void unmarshal_Tremove(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tremove *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
}

#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 void unmarshal_Tstat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tstat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
}

#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 void unmarshal_Tstatfs(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tstatfs *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
}

LM_FLATTEN static void unmarshal_Tlopen(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tlopen *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_4(ctx, &out->flags);
}

LM_FLATTEN static void unmarshal_Treadlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Treadlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
}

LM_FLATTEN static void unmarshal_Treaddir(struct _unmarshal_ctx *ctx, struct lib9p_msg_Treaddir *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_8(ctx, &out->offset);
	unmarshal_4(ctx, &out->count);
}

LM_FLATTEN static void unmarshal_Tfsync(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tfsync *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_4(ctx, &out->datasync);
}

#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 void unmarshal_Tversion(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tversion *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->max_msg_size);
	unmarshal_s(ctx, &out->version);
}

LM_FLATTEN static void unmarshal_Rversion(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rversion *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->max_msg_size);
	unmarshal_s(ctx, &out->version);
}

LM_FLATTEN static void unmarshal_Rerror(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rerror *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_s(ctx, &out->ename);
#if CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_u) ) unmarshal_4(ctx, &out->errno);
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

LM_FLATTEN static void unmarshal_Twalk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Twalk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_fid(ctx, &out->newfid);
	unmarshal_2(ctx, &out->nwname);
	out->wname = ctx->extra;
	ctx->extra += sizeof(out->wname[0]) * out->nwname;
	for (typeof(out->nwname) i = 0; i < out->nwname; i++)
		unmarshal_s(ctx, &out->wname[i]);
}

#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 void unmarshal_Trename(struct _unmarshal_ctx *ctx, struct lib9p_msg_Trename *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_fid(ctx, &out->dfid);
	unmarshal_s(ctx, &out->name);
}

LM_FLATTEN static void unmarshal_Rreadlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rreadlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_s(ctx, &out->target);
}

LM_FLATTEN static void unmarshal_Txattrwalk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Txattrwalk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_fid(ctx, &out->newfid);
	unmarshal_s(ctx, &out->name);
}

LM_FLATTEN static void unmarshal_Txattrcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Txattrcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_s(ctx, &out->name);
	unmarshal_8(ctx, &out->attr_size);
	unmarshal_4(ctx, &out->flags);
}

LM_FLATTEN static void unmarshal_Tgetlock(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tgetlock *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_1(ctx, &out->type);
	unmarshal_8(ctx, &out->start);
	unmarshal_8(ctx, &out->length);
	unmarshal_4(ctx, &out->proc_id);
	unmarshal_s(ctx, &out->client_id);
}

LM_FLATTEN static void unmarshal_Rgetlock(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rgetlock *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_1(ctx, &out->type);
	unmarshal_8(ctx, &out->start);
	unmarshal_8(ctx, &out->length);
	unmarshal_4(ctx, &out->proc_id);
	unmarshal_s(ctx, &out->client_id);
}

LM_FLATTEN static void unmarshal_Tlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->dfid);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_s(ctx, &out->name);
}

LM_FLATTEN static void unmarshal_Trenameat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Trenameat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->olddirfid);
	unmarshal_s(ctx, &out->oldname);
	unmarshal_fid(ctx, &out->newdirfid);
	unmarshal_s(ctx, &out->newname);
}

LM_FLATTEN static void unmarshal_Tunlinkat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tunlinkat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->dirfd);
	unmarshal_s(ctx, &out->name);
	unmarshal_4(ctx, &out->flags);
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
LM_FLATTEN static void unmarshal_Tsread(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tsread *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->fid);
	unmarshal_2(ctx, &out->nwname);
	out->wname = ctx->extra;
	ctx->extra += sizeof(out->wname[0]) * out->nwname;
	for (typeof(out->nwname) i = 0; i < out->nwname; i++)
		unmarshal_s(ctx, &out->wname[i]);
}

LM_FLATTEN static void unmarshal_Tswrite(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tswrite *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_4(ctx, &out->fid);
	unmarshal_2(ctx, &out->nwname);
	out->wname = ctx->extra;
	ctx->extra += sizeof(out->wname[0]) * out->nwname;
	for (typeof(out->nwname) i = 0; i < out->nwname; i++)
		unmarshal_s(ctx, &out->wname[i]);
	unmarshal_4(ctx, &out->count);
	out->data = (char *)&ctx->net_bytes[ctx->net_offset];
	ctx->net_offset += out->count;
}

#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 void unmarshal_qid(struct _unmarshal_ctx *ctx, struct lib9p_qid *out) {
	memset(out, 0, sizeof(*out));
	unmarshal_qt(ctx, &out->type);
	unmarshal_4(ctx, &out->vers);
	unmarshal_8(ctx, &out->path);
}

LM_FLATTEN static void unmarshal_Tauth(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tauth *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->afid);
	unmarshal_s(ctx, &out->uname);
	unmarshal_s(ctx, &out->aname);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) ) unmarshal_nuid(ctx, &out->n_uid);
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
}

LM_FLATTEN static void unmarshal_Tattach(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tattach *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_fid(ctx, &out->afid);
	unmarshal_s(ctx, &out->uname);
	unmarshal_s(ctx, &out->aname);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) ) unmarshal_nuid(ctx, &out->n_uid);
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
}

#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 void unmarshal_Tlcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tlcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_s(ctx, &out->name);
	unmarshal_4(ctx, &out->flags);
	unmarshal_4(ctx, &out->mode);
	unmarshal_nuid(ctx, &out->gid);
}

LM_FLATTEN static void unmarshal_Tsymlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tsymlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_s(ctx, &out->name);
	unmarshal_s(ctx, &out->symtgt);
	unmarshal_nuid(ctx, &out->gid);
}

LM_FLATTEN static void unmarshal_Tmknod(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tmknod *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->dfid);
	unmarshal_s(ctx, &out->name);
	unmarshal_4(ctx, &out->mode);
	unmarshal_4(ctx, &out->major);
	unmarshal_4(ctx, &out->minor);
	unmarshal_nuid(ctx, &out->gid);
}

LM_FLATTEN static void unmarshal_Tmkdir(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tmkdir *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->dfid);
	unmarshal_s(ctx, &out->name);
	unmarshal_4(ctx, &out->mode);
	unmarshal_nuid(ctx, &out->gid);
}

#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 void unmarshal_Topen(struct _unmarshal_ctx *ctx, struct lib9p_msg_Topen *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_o(ctx, &out->mode);
}

LM_FLATTEN static void unmarshal_Tcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_s(ctx, &out->name);
	unmarshal_dm(ctx, &out->perm);
	unmarshal_o(ctx, &out->mode);
}

#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 void unmarshal_Topenfd(struct _unmarshal_ctx *ctx, struct lib9p_msg_Topenfd *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_o(ctx, &out->mode);
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
LM_FLATTEN static void unmarshal_Tgetattr(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tgetattr *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_getattr(ctx, &out->request_mask);
}

LM_FLATTEN static void unmarshal_Tsetattr(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tsetattr *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_setattr(ctx, &out->valid);
	unmarshal_4(ctx, &out->mode);
	unmarshal_nuid(ctx, &out->uid);
	unmarshal_nuid(ctx, &out->gid);
	unmarshal_8(ctx, &out->filesize);
	unmarshal_8(ctx, &out->atime_sec);
	unmarshal_8(ctx, &out->atime_nsec);
	unmarshal_8(ctx, &out->mtime_sec);
	unmarshal_8(ctx, &out->mtime_nsec);
}

LM_FLATTEN static void unmarshal_Tlock(struct _unmarshal_ctx *ctx, struct lib9p_msg_Tlock *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	unmarshal_lock_type(ctx, &out->type);
	unmarshal_lock_flags(ctx, &out->flags);
	unmarshal_8(ctx, &out->start);
	unmarshal_8(ctx, &out->length);
	unmarshal_4(ctx, &out->proc_id);
	unmarshal_s(ctx, &out->client_id);
}

LM_FLATTEN static void unmarshal_Rlock(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rlock *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_lock_status(ctx, &out->status);
}

#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 void unmarshal_stat(struct _unmarshal_ctx *ctx, struct lib9p_stat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 2;
	unmarshal_2(ctx, &out->kern_type);
	unmarshal_4(ctx, &out->kern_dev);
	unmarshal_qid(ctx, &out->file_qid);
	unmarshal_dm(ctx, &out->file_mode);
	unmarshal_4(ctx, &out->file_atime);
	unmarshal_4(ctx, &out->file_mtime);
	unmarshal_8(ctx, &out->file_size);
	unmarshal_s(ctx, &out->file_name);
	unmarshal_s(ctx, &out->file_owner_uid);
	unmarshal_s(ctx, &out->file_owner_gid);
	unmarshal_s(ctx, &out->file_last_modified_uid);
#if CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_u) ) unmarshal_s(ctx, &out->file_extension);
	if ( is_ver(ctx, 9P2000_u) ) unmarshal_nuid(ctx, &out->file_owner_n_uid);
	if ( is_ver(ctx, 9P2000_u) ) unmarshal_nuid(ctx, &out->file_owner_n_gid);
	if ( is_ver(ctx, 9P2000_u) ) unmarshal_nuid(ctx, &out->file_last_modified_n_uid);
#endif /* CONFIG_9P_ENABLE_9P2000_u */
}

#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 void unmarshal_Rauth(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rauth *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->aqid);
}

LM_FLATTEN static void unmarshal_Rattach(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rattach *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
}

LM_FLATTEN static void unmarshal_Rwalk(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rwalk *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_2(ctx, &out->nwqid);
	out->wqid = ctx->extra;
	ctx->extra += sizeof(out->wqid[0]) * out->nwqid;
	for (typeof(out->nwqid) i = 0; i < out->nwqid; i++)
		unmarshal_qid(ctx, &out->wqid[i]);
}

#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 void unmarshal_Ropen(struct _unmarshal_ctx *ctx, struct lib9p_msg_Ropen *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->iounit);
}

LM_FLATTEN static void unmarshal_Rcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->iounit);
}

#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 void unmarshal_Ropenfd(struct _unmarshal_ctx *ctx, struct lib9p_msg_Ropenfd *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->iounit);
	unmarshal_4(ctx, &out->unixfd);
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
LM_FLATTEN static void unmarshal_Rlopen(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rlopen *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->iounit);
}

LM_FLATTEN static void unmarshal_Rlcreate(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rlcreate *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->iounit);
}

LM_FLATTEN static void unmarshal_Rsymlink(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rsymlink *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
}

LM_FLATTEN static void unmarshal_Rmknod(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rmknod *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
}

LM_FLATTEN static void unmarshal_Rgetattr(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rgetattr *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_8(ctx, &out->valid);
	unmarshal_qid(ctx, &out->qid);
	unmarshal_4(ctx, &out->mode);
	unmarshal_nuid(ctx, &out->uid);
	unmarshal_nuid(ctx, &out->gid);
	unmarshal_8(ctx, &out->nlink);
	unmarshal_8(ctx, &out->rdev);
	unmarshal_8(ctx, &out->filesize);
	unmarshal_8(ctx, &out->blksize);
	unmarshal_8(ctx, &out->blocks);
	unmarshal_8(ctx, &out->atime_sec);
	unmarshal_8(ctx, &out->atime_nsec);
	unmarshal_8(ctx, &out->mtime_sec);
	unmarshal_8(ctx, &out->mtime_nsec);
	unmarshal_8(ctx, &out->ctime_sec);
	unmarshal_8(ctx, &out->ctime_nsec);
	unmarshal_8(ctx, &out->btime_sec);
	unmarshal_8(ctx, &out->btime_nsec);
	unmarshal_8(ctx, &out->gen);
	unmarshal_8(ctx, &out->data_version);
}

LM_FLATTEN static void unmarshal_Rmkdir(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rmkdir *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_qid(ctx, &out->qid);
}

#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 void unmarshal_Rstat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Rstat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	ctx->net_offset += 2;
	unmarshal_stat(ctx, &out->stat);
}

LM_FLATTEN static void unmarshal_Twstat(struct _unmarshal_ctx *ctx, struct lib9p_msg_Twstat *out) {
	memset(out, 0, sizeof(*out));
	ctx->net_offset += 4;
	ctx->net_offset += 1;
	unmarshal_tag(ctx, &out->tag);
	unmarshal_fid(ctx, &out->fid);
	ctx->net_offset += 2;
	unmarshal_stat(ctx, &out->stat);
}
#endif /* CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u */

/* marshal_* ******************************************************************/

#define MARSHAL_BYTES_ZEROCOPY(ctx, data, len)             \
	if (ctx->net_iov[ctx->net_iov_cnt-1].iov_len)      \
		ctx->net_iov_cnt++;                        \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_base = data;  \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len = len;    \
	ctx->net_iov_cnt++;
#define MARSHAL_BYTES(ctx, data, len)                                                                \
	if (!ctx->net_iov[ctx->net_iov_cnt-1].iov_base)                                              \
		ctx->net_iov[ctx->net_iov_cnt-1].iov_base = &ctx->net_copied[ctx->net_copied_size];  \
	memcpy(&ctx->net_copied[ctx->net_copied_size], data, len);                                   \
	ctx->net_copied_size += len;                                                                 \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len += len;
#define MARSHAL_U8LE(ctx, val)                                                                       \
	if (!ctx->net_iov[ctx->net_iov_cnt-1].iov_base)                                              \
		ctx->net_iov[ctx->net_iov_cnt-1].iov_base = &ctx->net_copied[ctx->net_copied_size];  \
	ctx->net_copied[ctx->net_copied_size] = val;                                                 \
	ctx->net_copied_size += 1;                                                                   \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len += 1;
#define MARSHAL_U16LE(ctx, val)                                                                      \
	if (!ctx->net_iov[ctx->net_iov_cnt-1].iov_base)                                              \
		ctx->net_iov[ctx->net_iov_cnt-1].iov_base = &ctx->net_copied[ctx->net_copied_size];  \
	uint16le_encode(&ctx->net_copied[ctx->net_copied_size], val);                                \
	ctx->net_copied_size += 2;                                                                   \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len += 2;
#define MARSHAL_U32LE(ctx, val)                                                                      \
	if (!ctx->net_iov[ctx->net_iov_cnt-1].iov_base)                                              \
		ctx->net_iov[ctx->net_iov_cnt-1].iov_base = &ctx->net_copied[ctx->net_copied_size];  \
	uint32le_encode(&ctx->net_copied[ctx->net_copied_size], val);                                \
	ctx->net_copied_size += 4;                                                                   \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len += 4;
#define MARSHAL_U64LE(ctx, val)                                                                      \
	if (!ctx->net_iov[ctx->net_iov_cnt-1].iov_base)                                              \
		ctx->net_iov[ctx->net_iov_cnt-1].iov_base = &ctx->net_copied[ctx->net_copied_size];  \
	uint64le_encode(&ctx->net_copied[ctx->net_copied_size], val);                                \
	ctx->net_copied_size += 8;                                                                   \
	ctx->net_iov[ctx->net_iov_cnt-1].iov_len += 8;

#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_stat(struct _marshal_ctx *ctx, struct lib9p_stat *val) {
	uint32_t needed_size = 49 + val->file_name.len + val->file_owner_uid.len + val->file_owner_gid.len + val->file_last_modified_uid.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->file_extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_kern_type = 2;
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_kern_type);
	MARSHAL_U16LE(ctx, val->kern_type);
	MARSHAL_U32LE(ctx, val->kern_dev);
	MARSHAL_U8LE(ctx, val->file_qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->file_qid.vers);
	MARSHAL_U64LE(ctx, val->file_qid.path);
	MARSHAL_U32LE(ctx, val->file_mode & dm_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->file_atime);
	MARSHAL_U32LE(ctx, val->file_mtime);
	MARSHAL_U64LE(ctx, val->file_size);
	MARSHAL_U16LE(ctx, val->file_name.len);
	MARSHAL_BYTES(ctx, val->file_name.utf8, val->file_name.len);
	MARSHAL_U16LE(ctx, val->file_owner_uid.len);
	MARSHAL_BYTES(ctx, val->file_owner_uid.utf8, val->file_owner_uid.len);
	MARSHAL_U16LE(ctx, val->file_owner_gid.len);
	MARSHAL_BYTES(ctx, val->file_owner_gid.utf8, val->file_owner_gid.len);
	MARSHAL_U16LE(ctx, val->file_last_modified_uid.len);
	MARSHAL_BYTES(ctx, val->file_last_modified_uid.utf8, val->file_last_modified_uid.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->file_extension.len);
		MARSHAL_BYTES(ctx, val->file_extension.utf8, val->file_extension.len);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->file_owner_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->file_owner_n_gid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->file_last_modified_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

#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
static bool marshal_Tversion(struct _marshal_ctx *ctx, struct lib9p_msg_Tversion *val) {
	uint32_t needed_size = 13 + val->version.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tversion",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 100);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->max_msg_size);
	MARSHAL_U16LE(ctx, val->version.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->version.utf8, val->version.len);
	return false;
}

static bool marshal_Rversion(struct _marshal_ctx *ctx, struct lib9p_msg_Rversion *val) {
	uint32_t needed_size = 13 + val->version.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rversion",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 101);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->max_msg_size);
	MARSHAL_U16LE(ctx, val->version.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->version.utf8, val->version.len);
	return false;
}

static bool marshal_Tauth(struct _marshal_ctx *ctx, struct lib9p_msg_Tauth *val) {
	uint32_t needed_size = 15 + val->uname.len + val->aname.len;
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tauth",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 102);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->afid);
	MARSHAL_U16LE(ctx, val->uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->uname.utf8, val->uname.len);
	MARSHAL_U16LE(ctx, val->aname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->aname.utf8, val->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		MARSHAL_U32LE(ctx, val->n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rauth(struct _marshal_ctx *ctx, struct lib9p_msg_Rauth *val) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rauth",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 103);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->aqid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->aqid.vers);
	MARSHAL_U64LE(ctx, val->aqid.path);
	return false;
}

static bool marshal_Tattach(struct _marshal_ctx *ctx, struct lib9p_msg_Tattach *val) {
	uint32_t needed_size = 19 + val->uname.len + val->aname.len;
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if ( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) ) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tattach",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 104);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->afid);
	MARSHAL_U16LE(ctx, val->uname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->uname.utf8, val->uname.len);
	MARSHAL_U16LE(ctx, val->aname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->aname.utf8, val->aname.len);
#if CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u
	if (( is_ver(ctx, 9P2000_L) || is_ver(ctx, 9P2000_u) )) {
		MARSHAL_U32LE(ctx, val->n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rattach(struct _marshal_ctx *ctx, struct lib9p_msg_Rattach *val) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rattach",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 105);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Rerror(struct _marshal_ctx *ctx, struct lib9p_msg_Rerror *val) {
	uint32_t needed_size = 9 + val->ename.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 4;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rerror",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 107);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->ename.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->ename.utf8, val->ename.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->errno);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Tflush(struct _marshal_ctx *ctx, struct lib9p_msg_Tflush *val) {
	uint32_t needed_size = 9;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tflush",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 108);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->oldtag);
	return false;
}

static bool marshal_Rflush(struct _marshal_ctx *ctx, struct lib9p_msg_Rflush *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rflush",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 109);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Twalk(struct _marshal_ctx *ctx, struct lib9p_msg_Twalk *val) {
	uint32_t needed_size = 17;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Twalk",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 110);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->newfid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	return false;
}

static bool marshal_Rwalk(struct _marshal_ctx *ctx, struct lib9p_msg_Rwalk *val) {
	uint32_t needed_size = 9 + (val->nwqid)*13;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rwalk",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 111);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->nwqid);
	for (uint16_t i = 0; i < val->nwqid; i++) {
		MARSHAL_U8LE(ctx, val->wqid[i].type & qt_masks[ctx->ctx->version]);
		MARSHAL_U32LE(ctx, val->wqid[i].vers);
		MARSHAL_U64LE(ctx, val->wqid[i].path);
	}
	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 */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Topen(struct _marshal_ctx *ctx, struct lib9p_msg_Topen *val) {
	uint32_t needed_size = 12;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Topen",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 112);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->ctx->version]);
	return false;
}

static bool marshal_Ropen(struct _marshal_ctx *ctx, struct lib9p_msg_Ropen *val) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Ropen",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 113);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Tcreate *val) {
	uint32_t needed_size = 18 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tcreate",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 114);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->perm & dm_masks[ctx->ctx->version]);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->ctx->version]);
	return false;
}

static bool marshal_Rcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Rcreate *val) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rcreate",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 115);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

#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
static bool marshal_Tread(struct _marshal_ctx *ctx, struct lib9p_msg_Tread *val) {
	uint32_t needed_size = 23;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tread",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 116);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Rread(struct _marshal_ctx *ctx, struct lib9p_msg_Rread *val) {
	uint32_t needed_size = 11 + val->count;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rread",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 117);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Twrite(struct _marshal_ctx *ctx, struct lib9p_msg_Twrite *val) {
	uint32_t needed_size = 23 + val->count;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Twrite",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 118);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Rwrite(struct _marshal_ctx *ctx, struct lib9p_msg_Rwrite *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rwrite",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 119);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Tclunk(struct _marshal_ctx *ctx, struct lib9p_msg_Tclunk *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tclunk",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 120);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rclunk(struct _marshal_ctx *ctx, struct lib9p_msg_Rclunk *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rclunk",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 121);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tremove(struct _marshal_ctx *ctx, struct lib9p_msg_Tremove *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tremove",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 122);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rremove(struct _marshal_ctx *ctx, struct lib9p_msg_Rremove *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rremove",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 123);
	MARSHAL_U16LE(ctx, val->tag);
	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 */
#if CONFIG_9P_ENABLE_9P2000 || CONFIG_9P_ENABLE_9P2000_e || CONFIG_9P_ENABLE_9P2000_p9p || CONFIG_9P_ENABLE_9P2000_u
static bool marshal_Tstat(struct _marshal_ctx *ctx, struct lib9p_msg_Tstat *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tstat",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 124);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rstat(struct _marshal_ctx *ctx, struct lib9p_msg_Rstat *val) {
	uint32_t needed_size = 58 + val->stat.file_name.len + val->stat.file_owner_uid.len + val->stat.file_owner_gid.len + val->stat.file_last_modified_uid.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->stat.file_extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rstat",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	uint32_t offsetof_stat = 9;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 125);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_stat);
	uint32_t offsetof_stat_end = 49 + val->stat.file_name.len + val->stat.file_owner_uid.len + val->stat.file_owner_gid.len + val->stat.file_last_modified_uid.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		offsetof_stat_end += 14 + val->stat.file_extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_kern_type = 2;
	MARSHAL_U16LE(ctx, offsetof_stat_end - offsetof_stat_kern_type);
	MARSHAL_U16LE(ctx, val->stat.kern_type);
	MARSHAL_U32LE(ctx, val->stat.kern_dev);
	MARSHAL_U8LE(ctx, val->stat.file_qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.file_qid.vers);
	MARSHAL_U64LE(ctx, val->stat.file_qid.path);
	MARSHAL_U32LE(ctx, val->stat.file_mode & dm_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.file_atime);
	MARSHAL_U32LE(ctx, val->stat.file_mtime);
	MARSHAL_U64LE(ctx, val->stat.file_size);
	MARSHAL_U16LE(ctx, val->stat.file_name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_name.utf8, val->stat.file_name.len);
	MARSHAL_U16LE(ctx, val->stat.file_owner_uid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_owner_uid.utf8, val->stat.file_owner_uid.len);
	MARSHAL_U16LE(ctx, val->stat.file_owner_gid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_owner_gid.utf8, val->stat.file_owner_gid.len);
	MARSHAL_U16LE(ctx, val->stat.file_last_modified_uid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_last_modified_uid.utf8, val->stat.file_last_modified_uid.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->stat.file_extension.len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_extension.utf8, val->stat.file_extension.len);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_owner_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_owner_n_gid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_last_modified_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Twstat(struct _marshal_ctx *ctx, struct lib9p_msg_Twstat *val) {
	uint32_t needed_size = 62 + val->stat.file_name.len + val->stat.file_owner_uid.len + val->stat.file_owner_gid.len + val->stat.file_last_modified_uid.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		needed_size += 14 + val->stat.file_extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Twstat",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	uint32_t offsetof_stat = 13;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 126);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, offsetof_end - offsetof_stat);
	uint32_t offsetof_stat_end = 49 + val->stat.file_name.len + val->stat.file_owner_uid.len + val->stat.file_owner_gid.len + val->stat.file_last_modified_uid.len;
#if CONFIG_9P_ENABLE_9P2000_u
	if is_ver(ctx, 9P2000_u) {
		offsetof_stat_end += 14 + val->stat.file_extension.len;
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	uint32_t offsetof_stat_kern_type = 2;
	MARSHAL_U16LE(ctx, offsetof_stat_end - offsetof_stat_kern_type);
	MARSHAL_U16LE(ctx, val->stat.kern_type);
	MARSHAL_U32LE(ctx, val->stat.kern_dev);
	MARSHAL_U8LE(ctx, val->stat.file_qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.file_qid.vers);
	MARSHAL_U64LE(ctx, val->stat.file_qid.path);
	MARSHAL_U32LE(ctx, val->stat.file_mode & dm_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->stat.file_atime);
	MARSHAL_U32LE(ctx, val->stat.file_mtime);
	MARSHAL_U64LE(ctx, val->stat.file_size);
	MARSHAL_U16LE(ctx, val->stat.file_name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_name.utf8, val->stat.file_name.len);
	MARSHAL_U16LE(ctx, val->stat.file_owner_uid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_owner_uid.utf8, val->stat.file_owner_uid.len);
	MARSHAL_U16LE(ctx, val->stat.file_owner_gid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_owner_gid.utf8, val->stat.file_owner_gid.len);
	MARSHAL_U16LE(ctx, val->stat.file_last_modified_uid.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_last_modified_uid.utf8, val->stat.file_last_modified_uid.len);
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U16LE(ctx, val->stat.file_extension.len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->stat.file_extension.utf8, val->stat.file_extension.len);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_owner_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_owner_n_gid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
#if CONFIG_9P_ENABLE_9P2000_u
	if (is_ver(ctx, 9P2000_u)) {
		MARSHAL_U32LE(ctx, val->stat.file_last_modified_n_uid);
	}
#endif /* CONFIG_9P_ENABLE_9P2000_u */
	return false;
}

static bool marshal_Rwstat(struct _marshal_ctx *ctx, struct lib9p_msg_Rwstat *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rwstat",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 127);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

#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
static bool marshal_Topenfd(struct _marshal_ctx *ctx, struct lib9p_msg_Topenfd *val) {
	uint32_t needed_size = 12;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Topenfd",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 98);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->mode & o_masks[ctx->ctx->version]);
	return false;
}

static bool marshal_Ropenfd(struct _marshal_ctx *ctx, struct lib9p_msg_Ropenfd *val) {
	uint32_t needed_size = 28;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Ropenfd",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 99);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	MARSHAL_U32LE(ctx, val->unixfd);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_L
static bool marshal_Rlerror(struct _marshal_ctx *ctx, struct lib9p_msg_Rlerror *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rlerror",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 7);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->ecode);
	return false;
}

static bool marshal_Tstatfs(struct _marshal_ctx *ctx, struct lib9p_msg_Tstatfs *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tstatfs",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 8);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rstatfs(struct _marshal_ctx *ctx, struct lib9p_msg_Rstatfs *val) {
	uint32_t needed_size = 67;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rstatfs",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 9);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->type);
	MARSHAL_U32LE(ctx, val->bsize);
	MARSHAL_U64LE(ctx, val->blocks);
	MARSHAL_U64LE(ctx, val->bfree);
	MARSHAL_U64LE(ctx, val->bavail);
	MARSHAL_U64LE(ctx, val->files);
	MARSHAL_U64LE(ctx, val->ffree);
	MARSHAL_U64LE(ctx, val->fsid);
	MARSHAL_U32LE(ctx, val->namelen);
	return false;
}

static bool marshal_Tlopen(struct _marshal_ctx *ctx, struct lib9p_msg_Tlopen *val) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tlopen",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 12);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->flags);
	return false;
}

static bool marshal_Rlopen(struct _marshal_ctx *ctx, struct lib9p_msg_Rlopen *val) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rlopen",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 13);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tlcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Tlcreate *val) {
	uint32_t needed_size = 25 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tlcreate",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 14);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->flags);
	MARSHAL_U32LE(ctx, val->mode);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rlcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Rlcreate *val) {
	uint32_t needed_size = 24;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rlcreate",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 15);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->iounit);
	return false;
}

static bool marshal_Tsymlink(struct _marshal_ctx *ctx, struct lib9p_msg_Tsymlink *val) {
	uint32_t needed_size = 19 + val->name.len + val->symtgt.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tsymlink",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 16);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U16LE(ctx, val->symtgt.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->symtgt.utf8, val->symtgt.len);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rsymlink(struct _marshal_ctx *ctx, struct lib9p_msg_Rsymlink *val) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rsymlink",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 17);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Tmknod(struct _marshal_ctx *ctx, struct lib9p_msg_Tmknod *val) {
	uint32_t needed_size = 29 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tmknod",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 18);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->mode);
	MARSHAL_U32LE(ctx, val->major);
	MARSHAL_U32LE(ctx, val->minor);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rmknod(struct _marshal_ctx *ctx, struct lib9p_msg_Rmknod *val) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rmknod",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 19);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Trename(struct _marshal_ctx *ctx, struct lib9p_msg_Trename *val) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Trename",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 20);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rrename(struct _marshal_ctx *ctx, struct lib9p_msg_Rrename *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rrename",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 21);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Treadlink(struct _marshal_ctx *ctx, struct lib9p_msg_Treadlink *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Treadlink",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 22);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	return false;
}

static bool marshal_Rreadlink(struct _marshal_ctx *ctx, struct lib9p_msg_Rreadlink *val) {
	uint32_t needed_size = 9 + val->target.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rreadlink",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 23);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U16LE(ctx, val->target.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->target.utf8, val->target.len);
	return false;
}

static bool marshal_Tgetattr(struct _marshal_ctx *ctx, struct lib9p_msg_Tgetattr *val) {
	uint32_t needed_size = 19;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tgetattr",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 24);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->request_mask & getattr_masks[ctx->ctx->version]);
	return false;
}

static bool marshal_Rgetattr(struct _marshal_ctx *ctx, struct lib9p_msg_Rgetattr *val) {
	uint32_t needed_size = 160;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rgetattr",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 25);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->valid);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	MARSHAL_U32LE(ctx, val->mode);
	MARSHAL_U32LE(ctx, val->uid);
	MARSHAL_U32LE(ctx, val->gid);
	MARSHAL_U64LE(ctx, val->nlink);
	MARSHAL_U64LE(ctx, val->rdev);
	MARSHAL_U64LE(ctx, val->filesize);
	MARSHAL_U64LE(ctx, val->blksize);
	MARSHAL_U64LE(ctx, val->blocks);
	MARSHAL_U64LE(ctx, val->atime_sec);
	MARSHAL_U64LE(ctx, val->atime_nsec);
	MARSHAL_U64LE(ctx, val->mtime_sec);
	MARSHAL_U64LE(ctx, val->mtime_nsec);
	MARSHAL_U64LE(ctx, val->ctime_sec);
	MARSHAL_U64LE(ctx, val->ctime_nsec);
	MARSHAL_U64LE(ctx, val->btime_sec);
	MARSHAL_U64LE(ctx, val->btime_nsec);
	MARSHAL_U64LE(ctx, val->gen);
	MARSHAL_U64LE(ctx, val->data_version);
	return false;
}

static bool marshal_Tsetattr(struct _marshal_ctx *ctx, struct lib9p_msg_Tsetattr *val) {
	uint32_t needed_size = 67;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tsetattr",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 26);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->valid & setattr_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->mode);
	MARSHAL_U32LE(ctx, val->uid);
	MARSHAL_U32LE(ctx, val->gid);
	MARSHAL_U64LE(ctx, val->filesize);
	MARSHAL_U64LE(ctx, val->atime_sec);
	MARSHAL_U64LE(ctx, val->atime_nsec);
	MARSHAL_U64LE(ctx, val->mtime_sec);
	MARSHAL_U64LE(ctx, val->mtime_nsec);
	return false;
}

static bool marshal_Rsetattr(struct _marshal_ctx *ctx, struct lib9p_msg_Rsetattr *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rsetattr",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 27);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Txattrwalk(struct _marshal_ctx *ctx, struct lib9p_msg_Txattrwalk *val) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Txattrwalk",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 30);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->newfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rxattrwalk(struct _marshal_ctx *ctx, struct lib9p_msg_Rxattrwalk *val) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rxattrwalk",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 31);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->attr_size);
	return false;
}

static bool marshal_Txattrcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Txattrcreate *val) {
	uint32_t needed_size = 25 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Txattrcreate",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 32);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U64LE(ctx, val->attr_size);
	MARSHAL_U32LE(ctx, val->flags);
	return false;
}

static bool marshal_Rxattrcreate(struct _marshal_ctx *ctx, struct lib9p_msg_Rxattrcreate *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rxattrcreate",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 33);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Treaddir(struct _marshal_ctx *ctx, struct lib9p_msg_Treaddir *val) {
	uint32_t needed_size = 23;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Treaddir",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 40);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U64LE(ctx, val->offset);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}

static bool marshal_Rreaddir(struct _marshal_ctx *ctx, struct lib9p_msg_Rreaddir *val) {
	uint64_t needed_size = 11 + val->count;
	if (needed_size > (uint64_t)(ctx->ctx->max_msg_size)) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rreaddir",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 41);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Tfsync(struct _marshal_ctx *ctx, struct lib9p_msg_Tfsync *val) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tfsync",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 50);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U32LE(ctx, val->datasync);
	return false;
}

static bool marshal_Rfsync(struct _marshal_ctx *ctx, struct lib9p_msg_Rfsync *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rfsync",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 51);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tlock(struct _marshal_ctx *ctx, struct lib9p_msg_Tlock *val) {
	uint32_t needed_size = 38 + val->client_id.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tlock",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 52);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U32LE(ctx, val->flags & lock_flags_masks[ctx->ctx->version]);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Rlock(struct _marshal_ctx *ctx, struct lib9p_msg_Rlock *val) {
	uint32_t needed_size = 8;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rlock",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 53);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->status);
	return false;
}

static bool marshal_Tgetlock(struct _marshal_ctx *ctx, struct lib9p_msg_Tgetlock *val) {
	uint32_t needed_size = 34 + val->client_id.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tgetlock",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 54);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Rgetlock(struct _marshal_ctx *ctx, struct lib9p_msg_Rgetlock *val) {
	uint32_t needed_size = 30 + val->client_id.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rgetlock",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 55);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->type);
	MARSHAL_U64LE(ctx, val->start);
	MARSHAL_U64LE(ctx, val->length);
	MARSHAL_U32LE(ctx, val->proc_id);
	MARSHAL_U16LE(ctx, val->client_id.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->client_id.utf8, val->client_id.len);
	return false;
}

static bool marshal_Tlink(struct _marshal_ctx *ctx, struct lib9p_msg_Tlink *val) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tlink",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 70);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	return false;
}

static bool marshal_Rlink(struct _marshal_ctx *ctx, struct lib9p_msg_Rlink *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rlink",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 71);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tmkdir(struct _marshal_ctx *ctx, struct lib9p_msg_Tmkdir *val) {
	uint32_t needed_size = 21 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tmkdir",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 72);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dfid);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->mode);
	MARSHAL_U32LE(ctx, val->gid);
	return false;
}

static bool marshal_Rmkdir(struct _marshal_ctx *ctx, struct lib9p_msg_Rmkdir *val) {
	uint32_t needed_size = 20;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rmkdir",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 73);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U8LE(ctx, val->qid.type & qt_masks[ctx->ctx->version]);
	MARSHAL_U32LE(ctx, val->qid.vers);
	MARSHAL_U64LE(ctx, val->qid.path);
	return false;
}

static bool marshal_Trenameat(struct _marshal_ctx *ctx, struct lib9p_msg_Trenameat *val) {
	uint32_t needed_size = 19 + val->oldname.len + val->newname.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Trenameat",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 74);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->olddirfid);
	MARSHAL_U16LE(ctx, val->oldname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->oldname.utf8, val->oldname.len);
	MARSHAL_U32LE(ctx, val->newdirfid);
	MARSHAL_U16LE(ctx, val->newname.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->newname.utf8, val->newname.len);
	return false;
}

static bool marshal_Rrenameat(struct _marshal_ctx *ctx, struct lib9p_msg_Rrenameat *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rrenameat",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 75);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tunlinkat(struct _marshal_ctx *ctx, struct lib9p_msg_Tunlinkat *val) {
	uint32_t needed_size = 17 + val->name.len;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tunlinkat",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 76);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->dirfd);
	MARSHAL_U16LE(ctx, val->name.len);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->name.utf8, val->name.len);
	MARSHAL_U32LE(ctx, val->flags);
	return false;
}

static bool marshal_Runlinkat(struct _marshal_ctx *ctx, struct lib9p_msg_Runlinkat *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Runlinkat",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 77);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
static bool marshal_Tsession(struct _marshal_ctx *ctx, struct lib9p_msg_Tsession *val) {
	uint32_t needed_size = 15;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tsession",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 150);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U64LE(ctx, val->key);
	return false;
}

static bool marshal_Rsession(struct _marshal_ctx *ctx, struct lib9p_msg_Rsession *val) {
	uint32_t needed_size = 7;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rsession",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 151);
	MARSHAL_U16LE(ctx, val->tag);
	return false;
}

static bool marshal_Tsread(struct _marshal_ctx *ctx, struct lib9p_msg_Tsread *val) {
	uint64_t needed_size = 13;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > (uint64_t)(ctx->ctx->max_msg_size)) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tsread",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 152);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	return false;
}

static bool marshal_Rsread(struct _marshal_ctx *ctx, struct lib9p_msg_Rsread *val) {
	uint64_t needed_size = 11 + val->count;
	if (needed_size > (uint64_t)(ctx->ctx->max_msg_size)) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rsread",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 153);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Tswrite(struct _marshal_ctx *ctx, struct lib9p_msg_Tswrite *val) {
	uint64_t needed_size = 17 + val->count;
	for (uint16_t i = 0; i < val->nwname; i++) {
		needed_size += 2 + val->wname[i].len;
	}
	if (needed_size > (uint64_t)(ctx->ctx->max_msg_size)) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Tswrite",
			ctx->ctx->version ? "negotiated" : "client",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = (uint32_t)needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 154);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->fid);
	MARSHAL_U16LE(ctx, val->nwname);
	for (uint16_t i = 0; i < val->nwname; i++) {
		MARSHAL_U16LE(ctx, val->wname[i].len);
		MARSHAL_BYTES_ZEROCOPY(ctx, val->wname[i].utf8, val->wname[i].len);
	}
	MARSHAL_U32LE(ctx, val->count);
	MARSHAL_BYTES_ZEROCOPY(ctx, val->data, val->count);
	return false;
}

static bool marshal_Rswrite(struct _marshal_ctx *ctx, struct lib9p_msg_Rswrite *val) {
	uint32_t needed_size = 11;
	if (needed_size > ctx->ctx->max_msg_size) {
		lib9p_errorf(ctx->ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%PRIu32)",
			"Rswrite",
			ctx->ctx->version ? "negotiated" : "server",
			ctx->ctx->max_msg_size);
		return true;
	}
	uint32_t offsetof_end = needed_size;
	uint32_t offsetof_size = 0;
	MARSHAL_U32LE(ctx, offsetof_end - offsetof_size);
	MARSHAL_U8LE(ctx, 155);
	MARSHAL_U16LE(ctx, val->tag);
	MARSHAL_U32LE(ctx, val->count);
	return false;
}
#endif /* CONFIG_9P_ENABLE_9P2000_e */

/* function tables ************************************************************/

const uint32_t _lib9p_table_msg_min_size[LIB9P_VER_NUM] = {
	[LIB9P_VER_unknown] = 9,
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = 9,
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = 9,
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = 9,
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = 9,
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = 13,
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

#define _MSG_RECV(typ) [LIB9P_TYP_##typ/2] = {                  \
		.basesize  = sizeof(struct lib9p_msg_##typ),    \
		.validate  = validate_##typ,                    \
		.unmarshal = (_unmarshal_fn_t)unmarshal_##typ,  \
	}
#define _MSG_SEND(typ) [LIB9P_TYP_##typ/2] = {              \
		.marshal   = (_marshal_fn_t)marshal_##typ,  \
	}

const struct _lib9p_recv_tentry _lib9p_table_Tmsg_recv[LIB9P_VER_NUM][0x80] = {
	[LIB9P_VER_unknown] = {
		_MSG_RECV(Tversion),
	},
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_RECV(Tstatfs),
		_MSG_RECV(Tlopen),
		_MSG_RECV(Tlcreate),
		_MSG_RECV(Tsymlink),
		_MSG_RECV(Tmknod),
		_MSG_RECV(Trename),
		_MSG_RECV(Treadlink),
		_MSG_RECV(Tgetattr),
		_MSG_RECV(Tsetattr),
		_MSG_RECV(Txattrwalk),
		_MSG_RECV(Txattrcreate),
		_MSG_RECV(Treaddir),
		_MSG_RECV(Tfsync),
		_MSG_RECV(Tlock),
		_MSG_RECV(Tgetlock),
		_MSG_RECV(Tlink),
		_MSG_RECV(Tmkdir),
		_MSG_RECV(Trenameat),
		_MSG_RECV(Tunlinkat),
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
		_MSG_RECV(Tsession),
		_MSG_RECV(Tsread),
		_MSG_RECV(Tswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_RECV(Topenfd),
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_RECV(Tversion),
		_MSG_RECV(Tauth),
		_MSG_RECV(Tattach),
		_MSG_RECV(Tflush),
		_MSG_RECV(Twalk),
		_MSG_RECV(Topen),
		_MSG_RECV(Tcreate),
		_MSG_RECV(Tread),
		_MSG_RECV(Twrite),
		_MSG_RECV(Tclunk),
		_MSG_RECV(Tremove),
		_MSG_RECV(Tstat),
		_MSG_RECV(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

const struct _lib9p_recv_tentry _lib9p_table_Rmsg_recv[LIB9P_VER_NUM][0x80] = {
	[LIB9P_VER_unknown] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rerror),
	},
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_RECV(Rlerror),
		_MSG_RECV(Rstatfs),
		_MSG_RECV(Rlopen),
		_MSG_RECV(Rlcreate),
		_MSG_RECV(Rsymlink),
		_MSG_RECV(Rmknod),
		_MSG_RECV(Rrename),
		_MSG_RECV(Rreadlink),
		_MSG_RECV(Rgetattr),
		_MSG_RECV(Rsetattr),
		_MSG_RECV(Rxattrwalk),
		_MSG_RECV(Rxattrcreate),
		_MSG_RECV(Rreaddir),
		_MSG_RECV(Rfsync),
		_MSG_RECV(Rlock),
		_MSG_RECV(Rgetlock),
		_MSG_RECV(Rlink),
		_MSG_RECV(Rmkdir),
		_MSG_RECV(Rrenameat),
		_MSG_RECV(Runlinkat),
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
		_MSG_RECV(Rsession),
		_MSG_RECV(Rsread),
		_MSG_RECV(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_RECV(Ropenfd),
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_RECV(Rversion),
		_MSG_RECV(Rauth),
		_MSG_RECV(Rattach),
		_MSG_RECV(Rerror),
		_MSG_RECV(Rflush),
		_MSG_RECV(Rwalk),
		_MSG_RECV(Ropen),
		_MSG_RECV(Rcreate),
		_MSG_RECV(Rread),
		_MSG_RECV(Rwrite),
		_MSG_RECV(Rclunk),
		_MSG_RECV(Rremove),
		_MSG_RECV(Rstat),
		_MSG_RECV(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

const struct _lib9p_send_tentry _lib9p_table_Tmsg_send[LIB9P_VER_NUM][0x80] = {
	[LIB9P_VER_unknown] = {
		_MSG_SEND(Tversion),
	},
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_SEND(Tstatfs),
		_MSG_SEND(Tlopen),
		_MSG_SEND(Tlcreate),
		_MSG_SEND(Tsymlink),
		_MSG_SEND(Tmknod),
		_MSG_SEND(Trename),
		_MSG_SEND(Treadlink),
		_MSG_SEND(Tgetattr),
		_MSG_SEND(Tsetattr),
		_MSG_SEND(Txattrwalk),
		_MSG_SEND(Txattrcreate),
		_MSG_SEND(Treaddir),
		_MSG_SEND(Tfsync),
		_MSG_SEND(Tlock),
		_MSG_SEND(Tgetlock),
		_MSG_SEND(Tlink),
		_MSG_SEND(Tmkdir),
		_MSG_SEND(Trenameat),
		_MSG_SEND(Tunlinkat),
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
		_MSG_SEND(Tsession),
		_MSG_SEND(Tsread),
		_MSG_SEND(Tswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_SEND(Topenfd),
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_SEND(Tversion),
		_MSG_SEND(Tauth),
		_MSG_SEND(Tattach),
		_MSG_SEND(Tflush),
		_MSG_SEND(Twalk),
		_MSG_SEND(Topen),
		_MSG_SEND(Tcreate),
		_MSG_SEND(Tread),
		_MSG_SEND(Twrite),
		_MSG_SEND(Tclunk),
		_MSG_SEND(Tremove),
		_MSG_SEND(Tstat),
		_MSG_SEND(Twstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

const struct _lib9p_send_tentry _lib9p_table_Rmsg_send[LIB9P_VER_NUM][0x80] = {
	[LIB9P_VER_unknown] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rerror),
	},
#if CONFIG_9P_ENABLE_9P2000
	[LIB9P_VER_9P2000] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000 */
#if CONFIG_9P_ENABLE_9P2000_L
	[LIB9P_VER_9P2000_L] = {
		_MSG_SEND(Rlerror),
		_MSG_SEND(Rstatfs),
		_MSG_SEND(Rlopen),
		_MSG_SEND(Rlcreate),
		_MSG_SEND(Rsymlink),
		_MSG_SEND(Rmknod),
		_MSG_SEND(Rrename),
		_MSG_SEND(Rreadlink),
		_MSG_SEND(Rgetattr),
		_MSG_SEND(Rsetattr),
		_MSG_SEND(Rxattrwalk),
		_MSG_SEND(Rxattrcreate),
		_MSG_SEND(Rreaddir),
		_MSG_SEND(Rfsync),
		_MSG_SEND(Rlock),
		_MSG_SEND(Rgetlock),
		_MSG_SEND(Rlink),
		_MSG_SEND(Rmkdir),
		_MSG_SEND(Rrenameat),
		_MSG_SEND(Runlinkat),
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_L */
#if CONFIG_9P_ENABLE_9P2000_e
	[LIB9P_VER_9P2000_e] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
		_MSG_SEND(Rsession),
		_MSG_SEND(Rsread),
		_MSG_SEND(Rswrite),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_e */
#if CONFIG_9P_ENABLE_9P2000_p9p
	[LIB9P_VER_9P2000_p9p] = {
		_MSG_SEND(Ropenfd),
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_p9p */
#if CONFIG_9P_ENABLE_9P2000_u
	[LIB9P_VER_9P2000_u] = {
		_MSG_SEND(Rversion),
		_MSG_SEND(Rauth),
		_MSG_SEND(Rattach),
		_MSG_SEND(Rerror),
		_MSG_SEND(Rflush),
		_MSG_SEND(Rwalk),
		_MSG_SEND(Ropen),
		_MSG_SEND(Rcreate),
		_MSG_SEND(Rread),
		_MSG_SEND(Rwrite),
		_MSG_SEND(Rclunk),
		_MSG_SEND(Rremove),
		_MSG_SEND(Rstat),
		_MSG_SEND(Rwstat),
	},
#endif /* CONFIG_9P_ENABLE_9P2000_u */
};

LM_FLATTEN bool _lib9p_stat_validate(struct _validate_ctx *ctx) {
	return validate_stat(ctx);
}
LM_FLATTEN void _lib9p_stat_unmarshal(struct _unmarshal_ctx *ctx, struct lib9p_stat *out) {
	unmarshal_stat(ctx, out);
}
LM_FLATTEN bool _lib9p_stat_marshal(struct _marshal_ctx *ctx, struct lib9p_stat *val) {
	return marshal_stat(ctx, val);
}