lib9p_core: linux-errno.h: Rename LINUX_* => LIB9P_ERRNO_L_*

1 files changed, 283 insertions, 283 deletions

diff --git a/lib9p/core_generated.c b/lib9p/core_generated.c
index 544e9cd..0606373 100644
--- a/lib9p/core_generated.c
+++ b/lib9p/core_generated.c
@@ -318,27 +318,27 @@ static const lib9p_lock_flags_t lock_flags_masks[LIB9P_VER_NUM] = {
 
 /* validate_* *****************************************************************/
 
-#define VALIDATE_NET_BYTES(n)                                                               \
-	if (__builtin_add_overflow(net_offset, n, &net_offset))                             \
-		/* If needed-net-size overflowed uint32_t, then                             \
-		 * there's no way that actual-net-size will live up to                      \
-		 * that.  */                                                                \
-		return lib9p_error(ctx, LINUX_EBADMSG, "message is too short for content"); \
-	if (net_offset > net_size)                                                          \
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "message is too short for content (%"PRIu32" > %"PRIu32") @ %d", net_offset, net_size, __LINE__);
-#define VALIDATE_NET_UTF8(n)                                                                      \
-	{                                                                                         \
-		size_t len = n;                                                                   \
-		VALIDATE_NET_BYTES(len);                                                          \
-		if (!is_valid_utf8_without_nul(&net_bytes[net_offset-len], len))                  \
-			return lib9p_error(ctx, LINUX_EBADMSG, "message contains invalid UTF-8"); \
+#define VALIDATE_NET_BYTES(n)                                                                       \
+	if (__builtin_add_overflow(net_offset, n, &net_offset))                                     \
+		/* If needed-net-size overflowed uint32_t, then                                     \
+		 * there's no way that actual-net-size will live up to                              \
+		 * that.  */                                                                        \
+		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content"); \
+	if (net_offset > net_size)                                                                  \
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content (%"PRIu32" > %"PRIu32") @ %d", net_offset, net_size, __LINE__);
+#define VALIDATE_NET_UTF8(n)                                                                              \
+	{                                                                                                 \
+		size_t len = n;                                                                           \
+		VALIDATE_NET_BYTES(len);                                                                  \
+		if (!is_valid_utf8_without_nul(&net_bytes[net_offset-len], len))                          \
+			return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message contains invalid UTF-8"); \
 	}
 #define RESERVE_HOST_BYTES(n)                                           \
 	if (__builtin_add_overflow(host_size, n, &host_size))           \
 		/* If needed-host-size overflowed ssize_t, then there's \
 		 * no way that actual-net-size will live up to          \
 		 * that.  */                                            \
-		return lib9p_error(ctx, LINUX_EBADMSG, "message is too short for content");
+		return lib9p_error(ctx, LIB9P_ERRNO_L_EBADMSG, "message is too short for content");
 #define GET_U8LE(off)  (net_bytes[off])
 #define GET_U16LE(off) uint16le_decode(&net_bytes[off])
 #define GET_U32LE(off) uint32le_decode(&net_bytes[off])
@@ -357,7 +357,7 @@ static ssize_t validate_stat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *
 	uint32_t offsetof_file_qid_type = net_offset + 8;
 	VALIDATE_NET_BYTES(21);
 	if (GET_U8LE(offsetof_file_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_file_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_file_mode = net_offset + 0;
 	VALIDATE_NET_BYTES(22);
@@ -377,10 +377,10 @@ static ssize_t validate_stat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t *
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_stat_size) != (uint32_t)(offsetof_end - offsetof_kern_type))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "stat->stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "stat->stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_stat_size), (uint32_t)(offsetof_end - offsetof_kern_type));
 	if (GET_U32LE(offsetof_file_mode) & ~dm_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_file_mode) & ~dm_masks[ctx->version]);
 	if (ret_net_size)
 		*ret_net_size = net_offset;
@@ -398,10 +398,10 @@ static ssize_t validate_Tversion(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(100))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(100));
 	return (ssize_t)host_size;
 }
@@ -415,10 +415,10 @@ static ssize_t validate_Rversion(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rversion->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(101))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rversion->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(101));
 	return (ssize_t)host_size;
 }
@@ -439,10 +439,10 @@ static ssize_t validate_Tauth(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(102))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(102));
 	return (ssize_t)host_size;
 }
@@ -455,14 +455,14 @@ static ssize_t validate_Rauth(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_aqid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_aqid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rauth->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(103))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rauth->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(103));
 	return (ssize_t)host_size;
 }
@@ -483,10 +483,10 @@ static ssize_t validate_Tattach(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(104))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(104));
 	return (ssize_t)host_size;
 }
@@ -499,14 +499,14 @@ static ssize_t validate_Rattach(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rattach->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(105))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rattach->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(105));
 	return (ssize_t)host_size;
 }
@@ -527,10 +527,10 @@ static ssize_t validate_Rerror(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(107))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(107));
 	return (ssize_t)host_size;
 }
@@ -545,10 +545,10 @@ static ssize_t validate_Tflush(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 9;
 	VALIDATE_NET_BYTES(9);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(108))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(108));
 	return (ssize_t)host_size;
 }
@@ -561,10 +561,10 @@ static ssize_t validate_Rflush(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rflush->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(109))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rflush->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(109));
 	return (ssize_t)host_size;
 }
@@ -583,13 +583,13 @@ static ssize_t validate_Twalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	}
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(110))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(110));
 	if ((uint16_t)GET_U16LE(offsetof_nwname) > (uint16_t)(16))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twalk->nwname value is too large: %"PRIu16" > %"PRIu16,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twalk->nwname value is too large: %"PRIu16" > %"PRIu16,
 			(uint16_t)GET_U16LE(offsetof_nwname), (uint16_t)(16));
 	return (ssize_t)host_size;
 }
@@ -606,18 +606,18 @@ static ssize_t validate_Rwalk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 		uint32_t offsetof_wqid_type = net_offset + 0;
 		VALIDATE_NET_BYTES(13);
 		if (GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->version])
-			return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+			return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 				GET_U8LE(offsetof_wqid_type) & ~qt_masks[ctx->version]);
 	}
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(111))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(111));
 	if ((uint16_t)GET_U16LE(offsetof_nwqid) > (uint16_t)(16))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwalk->nwqid value is too large: %"PRIu16" > %"PRIu16,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwalk->nwqid value is too large: %"PRIu16" > %"PRIu16,
 			(uint16_t)GET_U16LE(offsetof_nwqid), (uint16_t)(16));
 	return (ssize_t)host_size;
 }
@@ -633,13 +633,13 @@ static ssize_t validate_Topen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 12;
 	VALIDATE_NET_BYTES(12);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Topen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Topen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(112))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Topen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Topen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(112));
 	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -652,15 +652,15 @@ static ssize_t validate_Ropen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Ropen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(113))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Ropen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(113));
 	return (ssize_t)host_size;
 }
@@ -677,16 +677,16 @@ static ssize_t validate_Tcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 5;
 	VALIDATE_NET_BYTES(5);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(114))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(114));
 	if (GET_U32LE(offsetof_perm) & ~dm_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_perm) & ~dm_masks[ctx->version]);
 	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -699,15 +699,15 @@ static ssize_t validate_Rcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(115))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(115));
 	return (ssize_t)host_size;
 }
@@ -724,16 +724,16 @@ static ssize_t validate_Tread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 23;
 	VALIDATE_NET_BYTES(23);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(116))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(116));
 	if ((uint64_t)GET_U64LE(offsetof_offset) > (uint64_t)(INT64_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tread->offset value is too large: %"PRIu64" > %"PRIu64,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->offset value is too large: %"PRIu64" > %"PRIu64,
 			(uint64_t)GET_U64LE(offsetof_offset), (uint64_t)(INT64_MAX));
 	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tread->count value is too large: %"PRIu32" > %"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tread->count value is too large: %"PRIu32" > %"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
 	return (ssize_t)host_size;
 }
@@ -748,13 +748,13 @@ static ssize_t validate_Rread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	VALIDATE_NET_BYTES(LAST_U32LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(117))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(117));
 	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rread->count value is too large: %"PRIu32" > %"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rread->count value is too large: %"PRIu32" > %"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
 	return (ssize_t)host_size;
 }
@@ -770,16 +770,16 @@ static ssize_t validate_Twrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	VALIDATE_NET_BYTES(LAST_U32LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(118))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(118));
 	if ((uint64_t)GET_U64LE(offsetof_offset) > (uint64_t)(INT64_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twrite->offset value is too large: %"PRIu64" > %"PRIu64,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->offset value is too large: %"PRIu64" > %"PRIu64,
 			(uint64_t)GET_U64LE(offsetof_offset), (uint64_t)(INT64_MAX));
 	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twrite->count value is too large: %"PRIu32" > %"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twrite->count value is too large: %"PRIu32" > %"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
 	return (ssize_t)host_size;
 }
@@ -793,13 +793,13 @@ static ssize_t validate_Rwrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(119))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(119));
 	if ((uint32_t)GET_U32LE(offsetof_count) > (uint32_t)(INT32_MAX))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwrite->count value is too large: %"PRIu32" > %"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwrite->count value is too large: %"PRIu32" > %"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_count), (uint32_t)(INT32_MAX));
 	return (ssize_t)host_size;
 }
@@ -812,10 +812,10 @@ static ssize_t validate_Tclunk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(120))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(120));
 	return (ssize_t)host_size;
 }
@@ -828,10 +828,10 @@ static ssize_t validate_Rclunk(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rclunk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(121))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rclunk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(121));
 	return (ssize_t)host_size;
 }
@@ -844,10 +844,10 @@ static ssize_t validate_Tremove(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(122))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(122));
 	return (ssize_t)host_size;
 }
@@ -860,10 +860,10 @@ static ssize_t validate_Rremove(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rremove->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(123))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rremove->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(123));
 	return (ssize_t)host_size;
 }
@@ -878,10 +878,10 @@ static ssize_t validate_Tstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(124))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(124));
 	return (ssize_t)host_size;
 }
@@ -898,7 +898,7 @@ static ssize_t validate_Rstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_stat_file_qid_type = net_offset + 17;
 	VALIDATE_NET_BYTES(30);
 	if (GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_stat_file_mode = net_offset + 0;
 	VALIDATE_NET_BYTES(22);
@@ -918,20 +918,20 @@ static ssize_t validate_Rstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_stat_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_stat_stat_size) != (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_stat_stat_size), (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type));
 	if (GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(125))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(125));
 	if ((uint32_t)GET_U32LE(offsetof_nstat) != (uint32_t)(offsetof_end - offsetof_stat))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_nstat), (uint32_t)(offsetof_end - offsetof_stat));
 	return (ssize_t)host_size;
 }
@@ -948,7 +948,7 @@ static ssize_t validate_Twstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_stat_file_qid_type = net_offset + 21;
 	VALIDATE_NET_BYTES(34);
 	if (GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_stat_file_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_stat_file_mode = net_offset + 0;
 	VALIDATE_NET_BYTES(22);
@@ -968,20 +968,20 @@ static ssize_t validate_Twstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	uint32_t offsetof_stat_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_stat_stat_size) != (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->stat.stat_size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_stat_stat_size), (uint32_t)(offsetof_stat_end - offsetof_stat_kern_type));
 	if (GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in dm bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_stat_file_mode) & ~dm_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(126))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(126));
 	if ((uint32_t)GET_U32LE(offsetof_nstat) != (uint32_t)(offsetof_end - offsetof_stat))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Twstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Twstat->nstat value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_nstat), (uint32_t)(offsetof_end - offsetof_stat));
 	return (ssize_t)host_size;
 }
@@ -994,10 +994,10 @@ static ssize_t validate_Rwstat(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwstat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(127))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rwstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rwstat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(127));
 	return (ssize_t)host_size;
 }
@@ -1013,13 +1013,13 @@ static ssize_t validate_Topenfd(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 12;
 	VALIDATE_NET_BYTES(12);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Topenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Topenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(98))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Topenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Topenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(98));
 	if (GET_U8LE(offsetof_mode) & ~o_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in o bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_mode) & ~o_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1032,15 +1032,15 @@ static ssize_t validate_Ropenfd(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 8;
 	VALIDATE_NET_BYTES(8);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Ropenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropenfd->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(99))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Ropenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Ropenfd->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(99));
 	return (ssize_t)host_size;
 }
@@ -1055,10 +1055,10 @@ static ssize_t validate_Rlerror(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlerror->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(7))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlerror->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(7));
 	return (ssize_t)host_size;
 }
@@ -1071,10 +1071,10 @@ static ssize_t validate_Tstatfs(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(8))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(8));
 	return (ssize_t)host_size;
 }
@@ -1087,10 +1087,10 @@ static ssize_t validate_Rstatfs(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 67;
 	VALIDATE_NET_BYTES(67);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstatfs->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(9))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rstatfs->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(9));
 	return (ssize_t)host_size;
 }
@@ -1104,13 +1104,13 @@ static ssize_t validate_Tlopen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 15;
 	VALIDATE_NET_BYTES(15);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(12))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(12));
 	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1123,15 +1123,15 @@ static ssize_t validate_Rlopen(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlopen->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(13))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlopen->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(13));
 	return (ssize_t)host_size;
 }
@@ -1148,16 +1148,16 @@ static ssize_t validate_Tlcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 12;
 	VALIDATE_NET_BYTES(12);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(14))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(14));
 	if (GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lo bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_flags) & ~lo_masks[ctx->version]);
 	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1170,15 +1170,15 @@ static ssize_t validate_Rlcreate(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(15))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(15));
 	return (ssize_t)host_size;
 }
@@ -1195,10 +1195,10 @@ static ssize_t validate_Tsymlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(16))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(16));
 	return (ssize_t)host_size;
 }
@@ -1211,14 +1211,14 @@ static ssize_t validate_Rsymlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsymlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(17))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsymlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(17));
 	return (ssize_t)host_size;
 }
@@ -1234,13 +1234,13 @@ static ssize_t validate_Tmknod(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 16;
 	VALIDATE_NET_BYTES(16);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(18))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(18));
 	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1253,14 +1253,14 @@ static ssize_t validate_Rmknod(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmknod->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(19))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmknod->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(19));
 	return (ssize_t)host_size;
 }
@@ -1274,10 +1274,10 @@ static ssize_t validate_Trename(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Trename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Trename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(20))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Trename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Trename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(20));
 	return (ssize_t)host_size;
 }
@@ -1290,10 +1290,10 @@ static ssize_t validate_Rrename(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rrename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrename->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(21))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rrename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrename->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(21));
 	return (ssize_t)host_size;
 }
@@ -1306,10 +1306,10 @@ static ssize_t validate_Treadlink(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Treadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Treadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(22))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Treadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Treadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(22));
 	return (ssize_t)host_size;
 }
@@ -1323,10 +1323,10 @@ static ssize_t validate_Rreadlink(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rreadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreadlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(23))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rreadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreadlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(23));
 	return (ssize_t)host_size;
 }
@@ -1340,13 +1340,13 @@ static ssize_t validate_Tgetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 19;
 	VALIDATE_NET_BYTES(19);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(24))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(24));
 	if (GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
 			GET_U64LE(offsetof_request_mask) & ~getattr_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1360,22 +1360,22 @@ static ssize_t validate_Rgetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_qid_type = net_offset + 15;
 	VALIDATE_NET_BYTES(28);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_mode = net_offset + 0;
 	uint32_t offsetof_end = net_offset + 132;
 	VALIDATE_NET_BYTES(132);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(25))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(25));
 	if (GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in getattr bitfield: %#016"PRIx64,
 			GET_U64LE(offsetof_valid) & ~getattr_masks[ctx->version]);
 	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1390,16 +1390,16 @@ static ssize_t validate_Tsetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 67;
 	VALIDATE_NET_BYTES(67);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(26))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(26));
 	if (GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in setattr bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in setattr bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_valid) & ~setattr_masks[ctx->version]);
 	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1412,10 +1412,10 @@ static ssize_t validate_Rsetattr(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsetattr->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(27))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsetattr->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(27));
 	return (ssize_t)host_size;
 }
@@ -1429,10 +1429,10 @@ static ssize_t validate_Txattrwalk(struct lib9p_ctx *ctx, uint32_t net_size, uin
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Txattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(30))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Txattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(30));
 	return (ssize_t)host_size;
 }
@@ -1445,10 +1445,10 @@ static ssize_t validate_Rxattrwalk(struct lib9p_ctx *ctx, uint32_t net_size, uin
 	uint32_t offsetof_end = net_offset + 15;
 	VALIDATE_NET_BYTES(15);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rxattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrwalk->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(31))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rxattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrwalk->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(31));
 	return (ssize_t)host_size;
 }
@@ -1463,10 +1463,10 @@ static ssize_t validate_Txattrcreate(struct lib9p_ctx *ctx, uint32_t net_size, u
 	uint32_t offsetof_end = net_offset + 12;
 	VALIDATE_NET_BYTES(12);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Txattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(32))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Txattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Txattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(32));
 	return (ssize_t)host_size;
 }
@@ -1479,10 +1479,10 @@ static ssize_t validate_Rxattrcreate(struct lib9p_ctx *ctx, uint32_t net_size, u
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rxattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrcreate->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(33))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rxattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rxattrcreate->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(33));
 	return (ssize_t)host_size;
 }
@@ -1495,10 +1495,10 @@ static ssize_t validate_Treaddir(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 23;
 	VALIDATE_NET_BYTES(23);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Treaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Treaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(40))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Treaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Treaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(40));
 	return (ssize_t)host_size;
 }
@@ -1512,10 +1512,10 @@ static ssize_t validate_Rreaddir(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	VALIDATE_NET_BYTES(LAST_U32LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rreaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreaddir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(41))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rreaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rreaddir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(41));
 	return (ssize_t)host_size;
 }
@@ -1528,10 +1528,10 @@ static ssize_t validate_Tfsync(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 15;
 	VALIDATE_NET_BYTES(15);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(50))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(50));
 	return (ssize_t)host_size;
 }
@@ -1544,10 +1544,10 @@ static ssize_t validate_Rfsync(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rfsync->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(51))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rfsync->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(51));
 	return (ssize_t)host_size;
 }
@@ -1562,13 +1562,13 @@ static ssize_t validate_Tlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(52))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(52));
 	if (GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in lock_flags bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in lock_flags bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_flags) & ~lock_flags_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1581,10 +1581,10 @@ static ssize_t validate_Rlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 8;
 	VALIDATE_NET_BYTES(8);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(53))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(53));
 	return (ssize_t)host_size;
 }
@@ -1598,10 +1598,10 @@ static ssize_t validate_Tgetlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(54))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(54));
 	return (ssize_t)host_size;
 }
@@ -1615,10 +1615,10 @@ static ssize_t validate_Rgetlock(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetlock->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(55))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rgetlock->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(55));
 	return (ssize_t)host_size;
 }
@@ -1632,10 +1632,10 @@ static ssize_t validate_Tlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(70))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(70));
 	return (ssize_t)host_size;
 }
@@ -1648,10 +1648,10 @@ static ssize_t validate_Rlink(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlink->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(71))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rlink->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(71));
 	return (ssize_t)host_size;
 }
@@ -1667,13 +1667,13 @@ static ssize_t validate_Tmkdir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_end = net_offset + 8;
 	VALIDATE_NET_BYTES(8);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(72))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(72));
 	if (GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in mode bitfield: %#08"PRIx32,
 			GET_U32LE(offsetof_mode) & ~mode_masks[ctx->version]);
 	return (ssize_t)host_size;
 }
@@ -1686,14 +1686,14 @@ static ssize_t validate_Rmkdir(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	uint32_t offsetof_qid_type = net_offset + 7;
 	VALIDATE_NET_BYTES(20);
 	if (GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version])
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "unknown bits in qt bitfield: %#02"PRIx8,
 			GET_U8LE(offsetof_qid_type) & ~qt_masks[ctx->version]);
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmkdir->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(73))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rmkdir->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(73));
 	return (ssize_t)host_size;
 }
@@ -1709,10 +1709,10 @@ static ssize_t validate_Trenameat(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	VALIDATE_NET_UTF8(LAST_U16LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Trenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Trenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(74))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Trenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Trenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(74));
 	return (ssize_t)host_size;
 }
@@ -1725,10 +1725,10 @@ static ssize_t validate_Rrenameat(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rrenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrenameat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(75))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rrenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rrenameat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(75));
 	return (ssize_t)host_size;
 }
@@ -1743,10 +1743,10 @@ static ssize_t validate_Tunlinkat(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	uint32_t offsetof_end = net_offset + 4;
 	VALIDATE_NET_BYTES(4);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tunlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tunlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(76))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tunlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tunlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(76));
 	return (ssize_t)host_size;
 }
@@ -1759,10 +1759,10 @@ static ssize_t validate_Runlinkat(struct lib9p_ctx *ctx, uint32_t net_size, uint
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Runlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Runlinkat->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(77))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Runlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Runlinkat->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(77));
 	return (ssize_t)host_size;
 }
@@ -1777,10 +1777,10 @@ static ssize_t validate_Tsession(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 15;
 	VALIDATE_NET_BYTES(15);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(150))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(150));
 	return (ssize_t)host_size;
 }
@@ -1793,10 +1793,10 @@ static ssize_t validate_Rsession(struct lib9p_ctx *ctx, uint32_t net_size, uint8
 	uint32_t offsetof_end = net_offset + 7;
 	VALIDATE_NET_BYTES(7);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsession->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(151))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsession->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(151));
 	return (ssize_t)host_size;
 }
@@ -1814,10 +1814,10 @@ static ssize_t validate_Tsread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	}
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(152))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(152));
 	return (ssize_t)host_size;
 }
@@ -1831,10 +1831,10 @@ static ssize_t validate_Rsread(struct lib9p_ctx *ctx, uint32_t net_size, uint8_t
 	VALIDATE_NET_BYTES(LAST_U32LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsread->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(153))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rsread->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(153));
 	return (ssize_t)host_size;
 }
@@ -1854,10 +1854,10 @@ static ssize_t validate_Tswrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	VALIDATE_NET_BYTES(LAST_U32LE());
 	uint32_t offsetof_end = net_offset + 0;
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(154))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Tswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Tswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(154));
 	return (ssize_t)host_size;
 }
@@ -1870,10 +1870,10 @@ static ssize_t validate_Rswrite(struct lib9p_ctx *ctx, uint32_t net_size, uint8_
 	uint32_t offsetof_end = net_offset + 11;
 	VALIDATE_NET_BYTES(11);
 	if ((uint32_t)GET_U32LE(offsetof_size) != (uint32_t)(offsetof_end - offsetof_size))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rswrite->size value is wrong: actual: %"PRIu32" != correct:%"PRIu32,
 			(uint32_t)GET_U32LE(offsetof_size), (uint32_t)(offsetof_end - offsetof_size));
 	if ((uint8_t)GET_U8LE(offsetof_typ) != (uint8_t)(155))
-		return lib9p_errorf(ctx, LINUX_EBADMSG, "Rswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
+		return lib9p_errorf(ctx, LIB9P_ERRNO_L_EBADMSG, "Rswrite->typ value is wrong: actual: %"PRIu8" != correct:%"PRIu8,
 			(uint8_t)GET_U8LE(offsetof_typ), (uint8_t)(155));
 	return (ssize_t)host_size;
 }
@@ -3023,7 +3023,7 @@ static bool marshal_stat(struct lib9p_ctx *ctx, struct lib9p_stat *val, struct _
 static bool marshal_Tversion(struct lib9p_ctx *ctx, struct lib9p_msg_Tversion *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 13 + val->version.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tversion",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3043,7 +3043,7 @@ static bool marshal_Tversion(struct lib9p_ctx *ctx, struct lib9p_msg_Tversion *v
 static bool marshal_Rversion(struct lib9p_ctx *ctx, struct lib9p_msg_Rversion *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 13 + val->version.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rversion",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3068,7 +3068,7 @@ static bool marshal_Tauth(struct lib9p_ctx *ctx, struct lib9p_msg_Tauth *val, st
 	}
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tauth",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3095,7 +3095,7 @@ static bool marshal_Tauth(struct lib9p_ctx *ctx, struct lib9p_msg_Tauth *val, st
 static bool marshal_Rauth(struct lib9p_ctx *ctx, struct lib9p_msg_Rauth *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 20;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rauth",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3120,7 +3120,7 @@ static bool marshal_Tattach(struct lib9p_ctx *ctx, struct lib9p_msg_Tattach *val
 	}
 #endif /* CONFIG_9P_ENABLE_9P2000_L || CONFIG_9P_ENABLE_9P2000_u */
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tattach",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3148,7 +3148,7 @@ static bool marshal_Tattach(struct lib9p_ctx *ctx, struct lib9p_msg_Tattach *val
 static bool marshal_Rattach(struct lib9p_ctx *ctx, struct lib9p_msg_Rattach *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 20;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rattach",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3175,7 +3175,7 @@ static bool marshal_Rerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rerror *val,
 	}
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rerror",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3201,7 +3201,7 @@ static bool marshal_Rerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rerror *val,
 static bool marshal_Tflush(struct lib9p_ctx *ctx, struct lib9p_msg_Tflush *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 9;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tflush",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3219,7 +3219,7 @@ static bool marshal_Tflush(struct lib9p_ctx *ctx, struct lib9p_msg_Tflush *val,
 static bool marshal_Rflush(struct lib9p_ctx *ctx, struct lib9p_msg_Rflush *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rflush",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3239,7 +3239,7 @@ static bool marshal_Twalk(struct lib9p_ctx *ctx, struct lib9p_msg_Twalk *val, st
 		needed_size += 2 + val->wname[i].len;
 	}
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Twalk",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3263,7 +3263,7 @@ static bool marshal_Twalk(struct lib9p_ctx *ctx, struct lib9p_msg_Twalk *val, st
 static bool marshal_Rwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rwalk *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 9 + (val->nwqid)*13;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rwalk",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3288,7 +3288,7 @@ static bool marshal_Rwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rwalk *val, st
 static bool marshal_Topen(struct lib9p_ctx *ctx, struct lib9p_msg_Topen *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 12;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Topen",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3307,7 +3307,7 @@ static bool marshal_Topen(struct lib9p_ctx *ctx, struct lib9p_msg_Topen *val, st
 static bool marshal_Ropen(struct lib9p_ctx *ctx, struct lib9p_msg_Ropen *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 24;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Ropen",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3328,7 +3328,7 @@ static bool marshal_Ropen(struct lib9p_ctx *ctx, struct lib9p_msg_Ropen *val, st
 static bool marshal_Tcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 18 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tcreate",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3350,7 +3350,7 @@ static bool marshal_Tcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tcreate *val
 static bool marshal_Rcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 24;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rcreate",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3373,7 +3373,7 @@ static bool marshal_Rcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rcreate *val
 static bool marshal_Tread(struct lib9p_ctx *ctx, struct lib9p_msg_Tread *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 23;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tread",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3393,7 +3393,7 @@ static bool marshal_Tread(struct lib9p_ctx *ctx, struct lib9p_msg_Tread *val, st
 static bool marshal_Rread(struct lib9p_ctx *ctx, struct lib9p_msg_Rread *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11 + val->count;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rread",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3412,7 +3412,7 @@ static bool marshal_Rread(struct lib9p_ctx *ctx, struct lib9p_msg_Rread *val, st
 static bool marshal_Twrite(struct lib9p_ctx *ctx, struct lib9p_msg_Twrite *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 23 + val->count;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Twrite",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3433,7 +3433,7 @@ static bool marshal_Twrite(struct lib9p_ctx *ctx, struct lib9p_msg_Twrite *val,
 static bool marshal_Rwrite(struct lib9p_ctx *ctx, struct lib9p_msg_Rwrite *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rwrite",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3451,7 +3451,7 @@ static bool marshal_Rwrite(struct lib9p_ctx *ctx, struct lib9p_msg_Rwrite *val,
 static bool marshal_Tclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Tclunk *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tclunk",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3469,7 +3469,7 @@ static bool marshal_Tclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Tclunk *val,
 static bool marshal_Rclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Rclunk *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rclunk",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3486,7 +3486,7 @@ static bool marshal_Rclunk(struct lib9p_ctx *ctx, struct lib9p_msg_Rclunk *val,
 static bool marshal_Tremove(struct lib9p_ctx *ctx, struct lib9p_msg_Tremove *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tremove",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3504,7 +3504,7 @@ static bool marshal_Tremove(struct lib9p_ctx *ctx, struct lib9p_msg_Tremove *val
 static bool marshal_Rremove(struct lib9p_ctx *ctx, struct lib9p_msg_Rremove *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rremove",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3523,7 +3523,7 @@ static bool marshal_Rremove(struct lib9p_ctx *ctx, struct lib9p_msg_Rremove *val
 static bool marshal_Tstat(struct lib9p_ctx *ctx, struct lib9p_msg_Tstat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tstat",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3546,7 +3546,7 @@ static bool marshal_Rstat(struct lib9p_ctx *ctx, struct lib9p_msg_Rstat *val, st
 	}
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rstat",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3604,7 +3604,7 @@ static bool marshal_Twstat(struct lib9p_ctx *ctx, struct lib9p_msg_Twstat *val,
 	}
 #endif /* CONFIG_9P_ENABLE_9P2000_u */
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Twstat",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3658,7 +3658,7 @@ static bool marshal_Twstat(struct lib9p_ctx *ctx, struct lib9p_msg_Twstat *val,
 static bool marshal_Rwstat(struct lib9p_ctx *ctx, struct lib9p_msg_Rwstat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rwstat",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3677,7 +3677,7 @@ static bool marshal_Rwstat(struct lib9p_ctx *ctx, struct lib9p_msg_Rwstat *val,
 static bool marshal_Topenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Topenfd *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 12;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Topenfd",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3696,7 +3696,7 @@ static bool marshal_Topenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Topenfd *val
 static bool marshal_Ropenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Ropenfd *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 28;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Ropenfd",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3720,7 +3720,7 @@ static bool marshal_Ropenfd(struct lib9p_ctx *ctx, struct lib9p_msg_Ropenfd *val
 static bool marshal_Rlerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rlerror *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rlerror",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3738,7 +3738,7 @@ static bool marshal_Rlerror(struct lib9p_ctx *ctx, struct lib9p_msg_Rlerror *val
 static bool marshal_Tstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Tstatfs *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tstatfs",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3756,7 +3756,7 @@ static bool marshal_Tstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Tstatfs *val
 static bool marshal_Rstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Rstatfs *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 67;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rstatfs",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3782,7 +3782,7 @@ static bool marshal_Rstatfs(struct lib9p_ctx *ctx, struct lib9p_msg_Rstatfs *val
 static bool marshal_Tlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Tlopen *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 15;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tlopen",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3801,7 +3801,7 @@ static bool marshal_Tlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Tlopen *val,
 static bool marshal_Rlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Rlopen *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 24;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rlopen",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3822,7 +3822,7 @@ static bool marshal_Rlopen(struct lib9p_ctx *ctx, struct lib9p_msg_Rlopen *val,
 static bool marshal_Tlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tlcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 25 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tlcreate",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3845,7 +3845,7 @@ static bool marshal_Tlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Tlcreate *v
 static bool marshal_Rlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rlcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 24;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rlcreate",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3866,7 +3866,7 @@ static bool marshal_Rlcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rlcreate *v
 static bool marshal_Tsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tsymlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 19 + val->name.len + val->symtgt.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tsymlink",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3889,7 +3889,7 @@ static bool marshal_Tsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tsymlink *v
 static bool marshal_Rsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rsymlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 20;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rsymlink",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3909,7 +3909,7 @@ static bool marshal_Rsymlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rsymlink *v
 static bool marshal_Tmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Tmknod *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 29 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tmknod",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3933,7 +3933,7 @@ static bool marshal_Tmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Tmknod *val,
 static bool marshal_Rmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Rmknod *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 20;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rmknod",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3953,7 +3953,7 @@ static bool marshal_Rmknod(struct lib9p_ctx *ctx, struct lib9p_msg_Rmknod *val,
 static bool marshal_Trename(struct lib9p_ctx *ctx, struct lib9p_msg_Trename *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 17 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Trename",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -3974,7 +3974,7 @@ static bool marshal_Trename(struct lib9p_ctx *ctx, struct lib9p_msg_Trename *val
 static bool marshal_Rrename(struct lib9p_ctx *ctx, struct lib9p_msg_Rrename *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rrename",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -3991,7 +3991,7 @@ static bool marshal_Rrename(struct lib9p_ctx *ctx, struct lib9p_msg_Rrename *val
 static bool marshal_Treadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Treadlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Treadlink",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4009,7 +4009,7 @@ static bool marshal_Treadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Treadlink
 static bool marshal_Rreadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rreadlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 9 + val->target.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rreadlink",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4028,7 +4028,7 @@ static bool marshal_Rreadlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rreadlink
 static bool marshal_Tgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetattr *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 19;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tgetattr",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4047,7 +4047,7 @@ static bool marshal_Tgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetattr *v
 static bool marshal_Rgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetattr *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 160;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rgetattr",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4086,7 +4086,7 @@ static bool marshal_Rgetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetattr *v
 static bool marshal_Tsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tsetattr *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 67;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tsetattr",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4113,7 +4113,7 @@ static bool marshal_Tsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Tsetattr *v
 static bool marshal_Rsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rsetattr *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rsetattr",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4130,7 +4130,7 @@ static bool marshal_Rsetattr(struct lib9p_ctx *ctx, struct lib9p_msg_Rsetattr *v
 static bool marshal_Txattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrwalk *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 17 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Txattrwalk",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4151,7 +4151,7 @@ static bool marshal_Txattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrwal
 static bool marshal_Rxattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrwalk *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 15;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rxattrwalk",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4169,7 +4169,7 @@ static bool marshal_Rxattrwalk(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrwal
 static bool marshal_Txattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 25 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Txattrcreate",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4191,7 +4191,7 @@ static bool marshal_Txattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Txattrc
 static bool marshal_Rxattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrcreate *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rxattrcreate",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4208,7 +4208,7 @@ static bool marshal_Rxattrcreate(struct lib9p_ctx *ctx, struct lib9p_msg_Rxattrc
 static bool marshal_Treaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Treaddir *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 23;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Treaddir",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4228,7 +4228,7 @@ static bool marshal_Treaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Treaddir *v
 static bool marshal_Rreaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Rreaddir *val, struct _marshal_ret *ret) {
 	uint64_t needed_size = 11 + val->count;
 	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rreaddir",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4247,7 +4247,7 @@ static bool marshal_Rreaddir(struct lib9p_ctx *ctx, struct lib9p_msg_Rreaddir *v
 static bool marshal_Tfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Tfsync *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 15;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tfsync",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4266,7 +4266,7 @@ static bool marshal_Tfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Tfsync *val,
 static bool marshal_Rfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Rfsync *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rfsync",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4283,7 +4283,7 @@ static bool marshal_Rfsync(struct lib9p_ctx *ctx, struct lib9p_msg_Rfsync *val,
 static bool marshal_Tlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tlock *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 38 + val->client_id.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tlock",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4308,7 +4308,7 @@ static bool marshal_Tlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tlock *val, st
 static bool marshal_Rlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rlock *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 8;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rlock",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4326,7 +4326,7 @@ static bool marshal_Rlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rlock *val, st
 static bool marshal_Tgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetlock *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 34 + val->client_id.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tgetlock",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4350,7 +4350,7 @@ static bool marshal_Tgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Tgetlock *v
 static bool marshal_Rgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetlock *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 30 + val->client_id.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rgetlock",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4373,7 +4373,7 @@ static bool marshal_Rgetlock(struct lib9p_ctx *ctx, struct lib9p_msg_Rgetlock *v
 static bool marshal_Tlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 17 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tlink",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4394,7 +4394,7 @@ static bool marshal_Tlink(struct lib9p_ctx *ctx, struct lib9p_msg_Tlink *val, st
 static bool marshal_Rlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rlink *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rlink",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4411,7 +4411,7 @@ static bool marshal_Rlink(struct lib9p_ctx *ctx, struct lib9p_msg_Rlink *val, st
 static bool marshal_Tmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Tmkdir *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 21 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tmkdir",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4433,7 +4433,7 @@ static bool marshal_Tmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Tmkdir *val,
 static bool marshal_Rmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Rmkdir *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 20;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rmkdir",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4453,7 +4453,7 @@ static bool marshal_Rmkdir(struct lib9p_ctx *ctx, struct lib9p_msg_Rmkdir *val,
 static bool marshal_Trenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Trenameat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 19 + val->oldname.len + val->newname.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Trenameat",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4476,7 +4476,7 @@ static bool marshal_Trenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Trenameat
 static bool marshal_Rrenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Rrenameat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rrenameat",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4493,7 +4493,7 @@ static bool marshal_Rrenameat(struct lib9p_ctx *ctx, struct lib9p_msg_Rrenameat
 static bool marshal_Tunlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Tunlinkat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 17 + val->name.len;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tunlinkat",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4514,7 +4514,7 @@ static bool marshal_Tunlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Tunlinkat
 static bool marshal_Runlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Runlinkat *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Runlinkat",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4533,7 +4533,7 @@ static bool marshal_Runlinkat(struct lib9p_ctx *ctx, struct lib9p_msg_Runlinkat
 static bool marshal_Tsession(struct lib9p_ctx *ctx, struct lib9p_msg_Tsession *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 15;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tsession",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4551,7 +4551,7 @@ static bool marshal_Tsession(struct lib9p_ctx *ctx, struct lib9p_msg_Tsession *v
 static bool marshal_Rsession(struct lib9p_ctx *ctx, struct lib9p_msg_Rsession *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 7;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rsession",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4571,7 +4571,7 @@ static bool marshal_Tsread(struct lib9p_ctx *ctx, struct lib9p_msg_Tsread *val,
 		needed_size += 2 + val->wname[i].len;
 	}
 	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tsread",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4594,7 +4594,7 @@ static bool marshal_Tsread(struct lib9p_ctx *ctx, struct lib9p_msg_Tsread *val,
 static bool marshal_Rsread(struct lib9p_ctx *ctx, struct lib9p_msg_Rsread *val, struct _marshal_ret *ret) {
 	uint64_t needed_size = 11 + val->count;
 	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rsread",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);
@@ -4616,7 +4616,7 @@ static bool marshal_Tswrite(struct lib9p_ctx *ctx, struct lib9p_msg_Tswrite *val
 		needed_size += 2 + val->wname[i].len;
 	}
 	if (needed_size > (uint64_t)(ctx->max_msg_size)) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Tswrite",
 			ctx->version ? "negotiated" : "client",
 			ctx->max_msg_size);
@@ -4641,7 +4641,7 @@ static bool marshal_Tswrite(struct lib9p_ctx *ctx, struct lib9p_msg_Tswrite *val
 static bool marshal_Rswrite(struct lib9p_ctx *ctx, struct lib9p_msg_Rswrite *val, struct _marshal_ret *ret) {
 	uint32_t needed_size = 11;
 	if (needed_size > ctx->max_msg_size) {
-		lib9p_errorf(ctx, LINUX_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
+		lib9p_errorf(ctx, LIB9P_ERRNO_L_ERANGE, "%s message too large to marshal into %s limit (limit=%"PRIu32")",
 			"Rswrite",
 			ctx->version ? "negotiated" : "server",
 			ctx->max_msg_size);