lib9p: srv: clean up

2 files changed, 289 insertions, 213 deletions

diff --git a/lib9p/include/lib9p/srv.h b/lib9p/include/lib9p/srv.h
index 55bcba0..c56ee3f 100644
--- a/lib9p/include/lib9p/srv.h
+++ b/lib9p/include/lib9p/srv.h
@@ -7,26 +7,27 @@
 
 #include <lib9p/9p.h>
 
-CR_RPC_DECLARE(_lib9p_srv_reqch, struct lib9p_req *, bool)
+/* context ********************************************************************/
+
 CR_CHAN_DECLARE(_lib9p_srv_flushch, bool)
 
-struct lib9p_srv_reqctx {
-	struct lib9p_ctx        *base;
+struct lib9p_srv_ctx {
+	struct lib9p_ctx         basectx;
 	uint32_t                 uid;
 	char                    *uname;
 
 	_lib9p_srv_flushch_t     _flushch;
 };
 
-static inline bool lib9p_srv_flush_requested(struct lib9p_srv_reqctx *ctx) {
+static inline bool lib9p_srv_flush_requested(struct lib9p_srv_ctx *ctx) {
 	assert(ctx);
 	return _lib9p_srv_flushch_can_send(&ctx->_flushch);
 }
 
-static inline int lib9p_srv_acknowledge_flush(struct lib9p_srv_reqctx *ctx) {
+static inline int lib9p_srv_acknowledge_flush(struct lib9p_srv_ctx *ctx) {
 	assert(ctx);
 	assert(_lib9p_srv_flushch_can_send(&ctx->_flushch));
-	lib9p_error(ctx->base, LINUX_ECANCELED, "request canceled by flush");
+	lib9p_error(&ctx->basectx, LINUX_ECANCELED, "request canceled by flush");
 	_lib9p_srv_flushch_send(&ctx->_flushch, true);
 	return -1;
 }
@@ -35,31 +36,35 @@ static inline int lib9p_srv_acknowledge_flush(struct lib9p_srv_reqctx *ctx) {
 
 struct lib9p_srv_file_vtable {
 	/* all */
-	struct lib9p_srv_io      (*io         )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        lib9p_o_t flags);
-	struct lib9p_stat        (*stat       )(struct lib9p_srv_reqctx *ctx, void *impldata);
-	void                     (*wstat      )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        struct lib9p_stat new);
-	void                     (*remove     )(struct lib9p_srv_reqctx *ctx, void *impldata);
-	void                     (*free       )(struct lib9p_srv_reqctx *ctx, void *impldata);
+	struct lib9p_srv_io   (*io     )(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 lib9p_o_t flags);
+	struct lib9p_stat     (*stat   )(struct lib9p_srv_ctx *ctx, void *impl);
+	void                  (*wstat  )(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 struct lib9p_stat new);
+	void                  (*remove )(struct lib9p_srv_ctx *ctx, void *impl);
+	void                  (*free   )(struct lib9p_srv_ctx *ctx, void *impl);
 
 	/* dir */
-	struct lib9p_srv_file    (*openchild  )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        char *childname);
-	struct lib9p_srv_file    (*createchild)(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        char *childname, lib9p_dm_t perm, lib9p_o_t flags);
+	struct lib9p_srv_file (*dopen  )(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 char *childname);
+	struct lib9p_srv_file (*dcreate)(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 char *childname,
+	                                 lib9p_dm_t perm, lib9p_o_t flags);
 };
 
 struct lib9p_srv_io_dir_vtable {
-	size_t                   (*readdir    )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        struct lib9p_stat *buf, size_t count, size_t offset);
+	size_t                (*readdir)(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 struct lib9p_stat *buf, size_t count,
+	                                 size_t offset);
 };
 
 struct lib9p_srv_io_file_vtable {
-	uint32_t                 (*pread      )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        void *buf, uint32_t count, uint64_t offset);
-	uint32_t                 (*pwrite     )(struct lib9p_srv_reqctx *ctx, void *impldata,
-	                                        void *buf, uint32_t count, uint64_t offset);
+	uint32_t              (*pread  )(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 void *buf, uint32_t count,
+	                                 uint64_t offset);
+	uint32_t              (*pwrite )(struct lib9p_srv_ctx *ctx, void *impl,
+	                                 void *buf, uint32_t count,
+	                                 uint64_t offset);
 };
 
 /* objects you'll deal with ***************************************************/
@@ -84,20 +89,23 @@ struct lib9p_srv_io {
 	void                    *impldata;
 };
 
-/******************************************************************************/
+/* main server entrypoints ****************************************************/
+
+CR_RPC_DECLARE(_lib9p_srv_reqch, struct _lib9p_srv_req *, bool)
 
 struct lib9p_srv {
 	/* Things you provide */
-	int                              sockfd;
-	void /*TODO*/                    (*auth)(struct lib9p_srv_reqctx *ctx, char *treename);
-	struct lib9p_srv_file            (*rootdir)(struct lib9p_srv_reqctx *ctx, char *treename);
+	int                   sockfd;
+	void /*TODO*/         (*auth   )(struct lib9p_srv_ctx *ctx, char *treename);
+	struct lib9p_srv_file (*rootdir)(struct lib9p_srv_ctx *ctx, char *treename);
 
 	/* For internal use */
-	_lib9p_srv_reqch_t               _reqch;
+	_lib9p_srv_reqch_t    _reqch;
 };
 
 /**
  * Will just close the connection if a T-message has a size[4] <7.
+ *
  * @errno LINUX_EMSGSIZE T-message has size[4] bigger than max_msg_size
  * @errno LINUX_EDOM Tversion specified an impossibly small max_msg_size
  * @errno LINUX_EOPNOTSUPP T-message has an R-message type, or an unrecognized T-message type
diff --git a/lib9p/srv.c b/lib9p/srv.c
index 478a642..077db83 100644
--- a/lib9p/srv.c
+++ b/lib9p/srv.c
@@ -21,7 +21,7 @@
 
 #define NAME  reqmap
 #define KEY_T uint32_t
-#define VAL_T struct lib9p_srv_reqctx
+#define VAL_T struct _lib9p_srv_req *
 #define CAP   CONFIG_9P_MAX_REQS
 #include "map.h"
 
@@ -31,9 +31,9 @@
  *
  */
 
-/* struct lib9p_srv {} is defined in <lib9p/srv.h> */
+/* struct _srv_srv {} is defined in <lib9p/srv.h> */
 
-struct lib9p_conn {
+struct _srv_conn {
 	/* immutable */
 	struct lib9p_srv        *parent_srv;
 	int                      fd;
@@ -42,9 +42,9 @@ struct lib9p_conn {
 	cr_mutex_t               writelock;
 };
 
-struct lib9p_sess {
+struct _srv_sess {
 	/* immutable */
-	struct lib9p_conn       *parent_conn;
+	struct _srv_conn       *parent_conn;
 	enum lib9p_version       version;
 	uint32_t                 max_msg_size;
 	uint32_t                 rerror_overhead;
@@ -55,56 +55,78 @@ struct lib9p_sess {
 	struct fidmap            fids;
 };
 
-struct lib9p_req {
+struct _lib9p_srv_req {
 	/* immutable */
-	struct lib9p_sess       *parent_sess;
+	struct _srv_sess       *parent_sess;
 	uint16_t                 tag;
 	/* mutable */
 	uint8_t                 *net_bytes; /* CONFIG_9P_MAX_MSG_SIZE-sized */
-	struct lib9p_ctx         ctx;
+	struct lib9p_srv_ctx     ctx;
 };
 
 /* base utilities *************************************************************/
 
-#define nonrespond_errorf(fmt, ...) fprintf(stderr, "error: " fmt "\n" __VA_OPT__(,) __VA_ARGS__)
+#define nonrespond_errorf(fmt, ...) \
+	fprintf(stderr, "error: " fmt "\n" __VA_OPT__(,) __VA_ARGS__)
 
-static uint32_t rerror_overhead_for_version(enum lib9p_version version, uint8_t *scratch) {
+static uint32_t rerror_overhead_for_version(enum lib9p_version version,
+                                            uint8_t *scratch) {
 	struct lib9p_ctx empty_ctx = {
 		.version      = version,
 		.max_msg_size = CONFIG_9P_MAX_MSG_SIZE,
 	};
 	struct lib9p_msg_Rerror empty_error = { 0 };
+	bool e;
+
+	e = lib9p_marshal(&empty_ctx, LIB9P_TYP_Rerror,
+	                  0,            /* tag */
+	                  &empty_error, /* host_body */
+	                  scratch);      /* net_bytes */
+	assert(!e);
 
-	assert(!lib9p_marshal(&empty_ctx, LIB9P_TYP_Rerror, 0, &empty_error, scratch));
 	uint32_t min_msg_size = decode_u32le(scratch);
+
+	/* Assert that min_msg_size + biggest_possible_MAX_ERR_SIZE
+	 * won't overflow uint32... because using
+	 * __builtin_add_overflow in respond_error() would be a bit
+	 * much.  */
 	assert(min_msg_size < (UINT32_MAX - UINT16_MAX));
+	/* Assert that min_msg_size doesn't overflow MAX_MSG_SIZE.  */
 	assert(CONFIG_9P_MAX_MSG_SIZE >= min_msg_size);
 
 	return min_msg_size;
 }
 
-static void respond_error(struct lib9p_req *req) {
-	assert(req->ctx.err_num);
-	assert(req->ctx.err_msg[0]);
+static void respond_error(struct _lib9p_srv_req *req) {
+	assert(req->ctx.basectx.err_num);
+	assert(req->ctx.basectx.err_msg[0]);
 
 	ssize_t r;
 	struct lib9p_msg_Rerror host = {
 		.ename = {
-			.len = strnlen(req->ctx.err_msg, CONFIG_9P_MAX_ERR_SIZE),
-			.utf8 = req->ctx.err_msg,
+			.len = strnlen(req->ctx.basectx.err_msg,
+			               CONFIG_9P_MAX_ERR_SIZE),
+			.utf8 = req->ctx.basectx.err_msg,
 		},
-		.errno = req->ctx.err_num,
+		.errno = req->ctx.basectx.err_num,
 	};
 
-	/* Truncate the error-string if necessary to avoid needing to return ERANGE.  */
-	if (((uint32_t)host.ename.len) + req->parent_sess->rerror_overhead > req->parent_sess->max_msg_size)
-		host.ename.len = req->parent_sess->max_msg_size - req->parent_sess->rerror_overhead;
+	struct _srv_sess *sess = req->parent_sess;
 
-	lib9p_marshal(&req->ctx, LIB9P_TYP_Rerror, req->tag, &host, req->net_bytes);
+	/* Truncate the error-string if necessary to avoid needing to
+	 * return ERANGE.  The assert() in
+	 * rerror_overhead_for_version() has checked that this
+	 * addition doesn't overflow.  */
+	if (((uint32_t)host.ename.len) + sess->rerror_overhead > sess->max_msg_size)
+		host.ename.len = sess->max_msg_size - sess->rerror_overhead;
 
-	cr_mutex_lock(&req->parent_sess->parent_conn->writelock);
-	r = netio_write(req->parent_sess->parent_conn->fd, req->net_bytes, decode_u32le(req->net_bytes));
-	cr_mutex_unlock(&req->parent_sess->parent_conn->writelock);
+	lib9p_marshal(&req->ctx.basectx, LIB9P_TYP_Rerror,
+	              req->tag, &host, req->net_bytes);
+
+	cr_mutex_lock(&sess->parent_conn->writelock);
+	r = netio_write(sess->parent_conn->fd,
+	                req->net_bytes, decode_u32le(req->net_bytes));
+	cr_mutex_unlock(&sess->parent_conn->writelock);
 	if (r < 0)
 		nonrespond_errorf("write: %s", strerror(-r));
 }
@@ -130,7 +152,7 @@ static bool read_at_least(int fd, uint8_t *buf, size_t goal, size_t *done) {
 	return false;
 }
 
-static bool handle_Tmessage(struct lib9p_req *);
+static bool handle_Tmessage(struct _lib9p_srv_req *ctx);
 
 COROUTINE lib9p_srv_read_cr(void *_srv) {
 	uint8_t buf[CONFIG_9P_MAX_MSG_SIZE];
@@ -142,7 +164,7 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
 	uint32_t initial_rerror_overhead = rerror_overhead_for_version(0, buf);
 
 	for (;;) {
-		struct lib9p_conn conn = {
+		struct _srv_conn conn = {
 			.parent_srv = srv,
 			.fd         = netio_accept(srv->sockfd),
 			.reader     = cr_getcid(),
@@ -152,9 +174,9 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
 			continue;
 		}
 
-		struct lib9p_sess sess = {
+		struct _srv_sess sess = {
 			.parent_conn     = &conn,
-			.version         = 0,
+			.version         = LIB9P_VER_unknown,
 			.max_msg_size    = CONFIG_9P_MAX_MSG_SIZE,
 			.rerror_overhead = initial_rerror_overhead,
 			.initialized     = false,
@@ -171,18 +193,23 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
 			}
 			if (read_at_least(conn.fd, buf, 7, &done))
 				goto close;
-			struct lib9p_req req = {
+			struct _lib9p_srv_req req = {
 				.parent_sess = &sess,
 				.tag         = decode_u16le(&buf[5]),
 				.net_bytes   = buf,
 				.ctx         = {
-					.version      = sess.version,
-					.max_msg_size = sess.max_msg_size,
+					.basectx = {
+						.version      = sess.version,
+						.max_msg_size = sess.max_msg_size,
+					},
 				},
 			};
 			if (goal > sess.max_msg_size) {
-				lib9p_errorf(&req.ctx, LINUX_EMSGSIZE, "T-message larger than %s limit (%zu > %"PRIu32")",
-				             sess.initialized ? "negotiated" : "server", goal, sess.max_msg_size);
+				lib9p_errorf(&req.ctx.basectx,
+				             LINUX_EMSGSIZE, "T-message larger than %s limit (%zu > %"PRIu32")",
+				             sess.initialized ? "negotiated" : "server",
+				             goal,
+				             sess.max_msg_size);
 				respond_error(&req);
 				continue;
 			}
@@ -207,42 +234,33 @@ COROUTINE lib9p_srv_read_cr(void *_srv) {
 
 /* write coroutine ************************************************************/
 
-static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *req, struct lib9p_msg_Rversion *resp);
-static void handle_Tauth(struct lib9p_req *ctx, struct lib9p_msg_Tauth *req, struct lib9p_msg_Rauth *resp);
-static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req, struct lib9p_msg_Rattach *resp);
-static void handle_Tflush(struct lib9p_req *ctx, struct lib9p_msg_Tflush *req, struct lib9p_msg_Rflush *resp);
-static void handle_Twalk(struct lib9p_req *ctx, struct lib9p_msg_Twalk *req, struct lib9p_msg_Rwalk *resp);
-static void handle_Topen(struct lib9p_req *ctx, struct lib9p_msg_Topen *req, struct lib9p_msg_Ropen *resp);
-static void handle_Tcreate(struct lib9p_req *ctx, struct lib9p_msg_Tcreate *req, struct lib9p_msg_Rcreate *resp);
-static void handle_Tread(struct lib9p_req *ctx, struct lib9p_msg_Tread *req, struct lib9p_msg_Rread *resp);
-static void handle_Twrite(struct lib9p_req *ctx, struct lib9p_msg_Twrite *req, struct lib9p_msg_Rwrite *resp);
-static void handle_Tclunk(struct lib9p_req *ctx, struct lib9p_msg_Tclunk *req, struct lib9p_msg_Rclunk *resp);
-static void handle_Tremove(struct lib9p_req *ctx, struct lib9p_msg_Tremove *req, struct lib9p_msg_Rremove *resp);
-static void handle_Tstat(struct lib9p_req *ctx, struct lib9p_msg_Tstat *req, struct lib9p_msg_Rstat *resp);
-static void handle_Twstat(struct lib9p_req *ctx, struct lib9p_msg_Twstat *req, struct lib9p_msg_Rwstat *resp);
-static void handle_Tsession(struct lib9p_req *ctx, struct lib9p_msg_Tsession *req, struct lib9p_msg_Rsession *resp);
-static void handle_Tsread(struct lib9p_req *ctx, struct lib9p_msg_Tsread *req, struct lib9p_msg_Rsread *resp);
-static void handle_Tswrite(struct lib9p_req *ctx, struct lib9p_msg_Tswrite *req, struct lib9p_msg_Rswrite *resp);
-
 COROUTINE lib9p_srv_write_cr(void *_srv) {
-	uint8_t net[CONFIG_9P_MAX_MSG_SIZE];
+	uint8_t                 net[CONFIG_9P_MAX_MSG_SIZE];
+	struct _lib9p_srv_req   req;
+	_lib9p_srv_reqch_req_t  rpc_handle;
 
 	struct lib9p_srv *srv = _srv;
 	assert(srv);
 	cr_begin();
 
 	for (;;) {
-		/* Receive the request from the reader coroutine.  */
-		struct lib9p_req req;
-		_lib9p_srv_reqch_req_t req_handle;
-		req_handle = _lib9p_srv_reqch_recv_req(&srv->_reqch);
-		req = *req_handle.req;
+		/* Receive the request from the reader coroutine.  ************/
+		rpc_handle = _lib9p_srv_reqch_recv_req(&srv->_reqch);
+		/* Deep-copy the request from the reader coroutine's
+		 * stack to our stack.  */
+		req = *rpc_handle.req;
 		memcpy(net, req.net_bytes, decode_u32le(req.net_bytes));
 		req.net_bytes = net;
-		_lib9p_srv_reqch_send_resp(req_handle, 0); /* notify that we've copied req */
+		/* Record that we have it.  */
+		reqmap_store(&req.parent_sess->reqs, req.tag, &req);
+		/* Notify the reader coroutine that we're done with
+		 * its data.  */
+		_lib9p_srv_reqch_send_resp(rpc_handle, 0);
 
+		/* Process the request.  **************************************/
 		handle_Tmessage(&req);
 
+		/* Release resources.  ****************************************/
 		reqmap_del(&req.parent_sess->reqs, req.tag);
 		if (req.parent_sess->closing && !req.parent_sess->reqs.len)
 			cr_unpause(req.parent_sess->parent_conn->reader);
@@ -251,96 +269,95 @@ COROUTINE lib9p_srv_write_cr(void *_srv) {
 	cr_end();
 }
 
-static bool handle_Tmessage(struct lib9p_req *req) {
+#define _HANDLER_PROTO(typ)                                  \
+	static void handle_T##typ(struct _lib9p_srv_req *,   \
+	                          struct lib9p_msg_T##typ *, \
+	                          struct lib9p_msg_R##typ *)
+_HANDLER_PROTO(version);
+_HANDLER_PROTO(auth);
+_HANDLER_PROTO(attach);
+_HANDLER_PROTO(flush);
+_HANDLER_PROTO(walk);
+_HANDLER_PROTO(open);
+_HANDLER_PROTO(create);
+_HANDLER_PROTO(read);
+_HANDLER_PROTO(write);
+_HANDLER_PROTO(clunk);
+_HANDLER_PROTO(remove);
+_HANDLER_PROTO(stat);
+_HANDLER_PROTO(wstat);
+_HANDLER_PROTO(session); /* 9P2000.e */
+_HANDLER_PROTO(sread);   /* 9P2000.e */
+_HANDLER_PROTO(swrite);  /* 9P2000.e */
+
+typedef void (*tmessage_handler)(struct _lib9p_srv_req *, void *, void *);
+
+static tmessage_handler tmessage_handlers[0x100] = {
+	[LIB9P_TYP_Tversion] = (tmessage_handler)handle_Tversion,
+	[LIB9P_TYP_Tauth]    = (tmessage_handler)handle_Tauth,
+	[LIB9P_TYP_Tattach]  = (tmessage_handler)handle_Tattach,
+	[LIB9P_TYP_Tflush]   = (tmessage_handler)handle_Tflush,
+	[LIB9P_TYP_Twalk]    = (tmessage_handler)handle_Twalk,
+	[LIB9P_TYP_Topen]    = (tmessage_handler)handle_Topen,
+	[LIB9P_TYP_Tcreate]  = (tmessage_handler)handle_Tcreate,
+	[LIB9P_TYP_Tread]    = (tmessage_handler)handle_Tread,
+	[LIB9P_TYP_Twrite]   = (tmessage_handler)handle_Twrite,
+	[LIB9P_TYP_Tclunk]   = (tmessage_handler)handle_Tclunk,
+	[LIB9P_TYP_Tremove]  = (tmessage_handler)handle_Tremove,
+	[LIB9P_TYP_Tstat]    = (tmessage_handler)handle_Tstat,
+	[LIB9P_TYP_Twstat]   = (tmessage_handler)handle_Twstat,
+	[LIB9P_TYP_Tsession] = (tmessage_handler)handle_Tsession, /* 9P2000.e */
+	[LIB9P_TYP_Tsread]   = (tmessage_handler)handle_Tsread,   /* 9P2000.e */
+	[LIB9P_TYP_Tswrite]  = (tmessage_handler)handle_Tswrite,  /* 9P2000.e */
+};
+
+static bool handle_Tmessage(struct _lib9p_srv_req *ctx) {
 	uint8_t host_req[CONFIG_9P_MAX_HOSTMSG_SIZE];
 	uint8_t host_resp[CONFIG_9P_MAX_HOSTMSG_SIZE];
 
 	/* Unmarshal it.  */
-	enum lib9p_msg_type typ = req->net_bytes[4];
+	enum lib9p_msg_type typ = ctx->net_bytes[4];
 	if (typ % 2 != 0) {
-		lib9p_errorf(&req->ctx, LINUX_EOPNOTSUPP, "expected a T-message but got an R-message: message_type=%s",
+		lib9p_errorf(&ctx->ctx.basectx,
+		             LINUX_EOPNOTSUPP, "expected a T-message but got an R-message: message_type=%s",
 		             lib9p_msg_type_str(typ));
 		goto write;
 	}
-	ssize_t host_size = lib9p_validate(&req->ctx, req->net_bytes);
+	ssize_t host_size = lib9p_validate(&ctx->ctx.basectx, ctx->net_bytes);
 	if (host_size < 0)
 		goto write;
 	if ((size_t)host_size > sizeof(host_req)) {
-		lib9p_errorf(&req->ctx, LINUX_EMSGSIZE, "unmarshalled payload larger than server limit (%zu > %zu)",
+		lib9p_errorf(&ctx->ctx.basectx,
+		             LINUX_EMSGSIZE, "unmarshalled payload larger than server limit (%zu > %zu)",
 		             host_size, sizeof(host_req));
 		goto write;
 	}
-	lib9p_unmarshal(&req->ctx, req->net_bytes, &typ, &req->tag, host_req);
+	lib9p_unmarshal(&ctx->ctx.basectx, ctx->net_bytes,
+	                &typ, &ctx->tag, host_req);
 
 	/* Handle it.  */
-	switch (typ) {
-	case LIB9P_TYP_Tversion:
-		handle_Tversion(req, (struct lib9p_msg_Tversion *)host_req, (struct lib9p_msg_Rversion *)host_resp);
-		break;
-	case LIB9P_TYP_Tauth:
-		handle_Tauth(req, (struct lib9p_msg_Tauth *)host_req, (struct lib9p_msg_Rauth *)host_resp);
-		break;
-	case LIB9P_TYP_Tattach:
-		handle_Tattach(req, (struct lib9p_msg_Tattach *)host_req, (struct lib9p_msg_Rattach *)host_resp);
-		break;
-	case LIB9P_TYP_Tflush:
-		handle_Tflush(req, (struct lib9p_msg_Tflush *)host_req, (struct lib9p_msg_Rflush *)host_resp);
-		break;
-	case LIB9P_TYP_Twalk:
-		handle_Twalk(req, (struct lib9p_msg_Twalk *)host_req, (struct lib9p_msg_Rwalk *)host_resp);
-		break;
-	case LIB9P_TYP_Topen:
-		handle_Topen(req, (struct lib9p_msg_Topen *)host_req, (struct lib9p_msg_Ropen *)host_resp);
-		break;
-	case LIB9P_TYP_Tcreate:
-		handle_Tcreate(req, (struct lib9p_msg_Tcreate *)host_req, (struct lib9p_msg_Rcreate *)host_resp);
-		break;
-	case LIB9P_TYP_Tread:
-		handle_Tread(req, (struct lib9p_msg_Tread *)host_req, (struct lib9p_msg_Rread *)host_resp);
-		break;
-	case LIB9P_TYP_Twrite:
-		handle_Twrite(req, (struct lib9p_msg_Twrite *)host_req, (struct lib9p_msg_Rwrite *)host_resp);
-		break;
-	case LIB9P_TYP_Tclunk:
-		handle_Tclunk(req, (struct lib9p_msg_Tclunk *)host_req, (struct lib9p_msg_Rclunk *)host_resp);
-		break;
-	case LIB9P_TYP_Tremove:
-		handle_Tremove(req, (struct lib9p_msg_Tremove *)host_req, (struct lib9p_msg_Rremove *)host_resp);
-		break;
-	case LIB9P_TYP_Tstat:
-		handle_Tstat(req, (struct lib9p_msg_Tstat *)host_req, (struct lib9p_msg_Rstat *)host_resp);
-		break;
-	case LIB9P_TYP_Twstat:
-		handle_Twstat(req, (struct lib9p_msg_Twstat *)host_req, (struct lib9p_msg_Rwstat *)host_resp);
-		break;
-	case LIB9P_TYP_Tsession: /* 9P2000.e */
-		handle_Tsession(req, (struct lib9p_msg_Tsession *)host_req, (struct lib9p_msg_Rsession *)host_resp);
-		break;
-	case LIB9P_TYP_Tsread: /* 9P2000.e */
-		handle_Tsread(req, (struct lib9p_msg_Tsread *)host_req, (struct lib9p_msg_Rsread *)host_resp);
-		break;
-	case LIB9P_TYP_Tswrite: /* 9P2000.e */
-		handle_Tswrite(req, (struct lib9p_msg_Tswrite *)host_req, (struct lib9p_msg_Rswrite *)host_resp);
-		break;
-	default:
-		assert(false);
-	}
+	tmessage_handlers[typ](ctx, (void *)host_req, (void *)host_resp);
 
  write:
-	if (lib9p_ctx_has_error(&req->ctx)) {
-		respond_error(req);
+	if (lib9p_ctx_has_error(&ctx->ctx.basectx)) {
+		respond_error(ctx);
 		return true;
 	} else {
-		if (lib9p_marshal(&req->ctx, typ+1, req->tag, host_resp, req->net_bytes))
+		if (lib9p_marshal(&ctx->ctx.basectx, typ+1, ctx->tag, host_resp,
+		                  ctx->net_bytes))
 			goto write;
-		cr_mutex_lock(&req->parent_sess->parent_conn->writelock);
-		netio_write(req->parent_sess->parent_conn->fd, req->net_bytes, decode_u32le(req->net_bytes));
-		cr_mutex_unlock(&req->parent_sess->parent_conn->writelock);
+
+		cr_mutex_lock(&ctx->parent_sess->parent_conn->writelock);
+		netio_write(ctx->parent_sess->parent_conn->fd,
+		            ctx->net_bytes, decode_u32le(ctx->net_bytes));
+		cr_mutex_unlock(&ctx->parent_sess->parent_conn->writelock);
 		return false;
 	}
 }
 
-static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *req, struct lib9p_msg_Rversion *resp) {
+static void handle_Tversion(struct _lib9p_srv_req *ctx,
+                            struct lib9p_msg_Tversion *req,
+                            struct lib9p_msg_Rversion *resp) {
 	enum lib9p_version version = LIB9P_VER_unknown;
 
 	if (req->version.len >= 6 &&
@@ -361,14 +378,12 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
 
 	uint32_t min_msg_size = rerror_overhead_for_version(version, ctx->net_bytes);
 	if (req->max_msg_size < min_msg_size) {
-		lib9p_errorf(&ctx->ctx, LINUX_EDOM, "requested max_msg_size is less than minimum for %s (%"PRIu32" < %"PRIu32")",
+		lib9p_errorf(&ctx->ctx.basectx,
+		             LINUX_EDOM, "requested max_msg_size is less than minimum for %s (%"PRIu32" < %"PRIu32")",
 		             version, req->max_msg_size, min_msg_size);
 		return;
 	}
 
-	struct lib9p_srv_reqctx subctx = {
-		.base  = &ctx->ctx,
-	};
 	if (ctx->parent_sess->reqs.len) {
 		ctx->parent_sess->closing = true;
 		// TODO: send flush events
@@ -379,7 +394,7 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
 		uint32_t fid;
 		struct lib9p_srv_file *fptr;
 		MAP_FOREACH(&ctx->parent_sess->fids, fid, fptr) {
-			fptr->vtable.free(&subctx, fptr->impldata);
+			fptr->vtable.free(&ctx->ctx, fptr->impldata);
 			fidmap_del(&ctx->parent_sess->fids, fid);
 		}
 	}
@@ -395,75 +410,89 @@ static void handle_Tversion(struct lib9p_req *ctx, struct lib9p_msg_Tversion *re
 		: req->max_msg_size;
 }
 
-static void handle_Tauth(struct lib9p_req *ctx, struct lib9p_msg_Tauth *req, struct lib9p_msg_Rauth *UNUSED(resp)) {
-	if (!ctx->parent_sess->parent_conn->parent_srv->auth) {
-		lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "authentication not required");
+static void handle_Tauth(struct _lib9p_srv_req *ctx,
+                         struct lib9p_msg_Tauth *req,
+                         struct lib9p_msg_Rauth *UNUSED(resp)) {
+	ctx->ctx.uid = req->n_uname;
+	ctx->ctx.uname = req->uname.utf8;
+	struct lib9p_srv *srv = ctx->parent_sess->parent_conn->parent_srv;
+
+	if (!srv->auth) {
+		lib9p_error(&ctx->ctx.basectx,
+		            LINUX_EOPNOTSUPP, "authentication not required");
 		return;
 	}
-	struct lib9p_srv_reqctx subctx = {
-		.base  = &ctx->ctx,
-		.uid   = req->n_uname,
-		.uname = req->uname.utf8,
-	};
-	ctx->parent_sess->parent_conn->parent_srv->auth(&subctx, req->aname.utf8);
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "TODO: auth not implemented");
+
+	srv->auth(&ctx->ctx, req->aname.utf8);
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "TODO: auth not implemented");
 }
 
-static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req, struct lib9p_msg_Rattach *resp) {
-	struct lib9p_srv_reqctx subctx = {
-		.base  = &ctx->ctx,
-		.uid   = req->n_uname,
-		.uname = req->uname.utf8,
-	};
-	if (ctx->parent_sess->parent_conn->parent_srv->auth) {
+static void handle_Tattach(struct _lib9p_srv_req *ctx,
+                           struct lib9p_msg_Tattach *req,
+                           struct lib9p_msg_Rattach *resp) {
+	ctx->ctx.uid = req->n_uname;
+	ctx->ctx.uname = req->uname.utf8;
+	struct lib9p_srv *srv = ctx->parent_sess->parent_conn->parent_srv;
+
+	if (srv->auth) {
 		/*
 		struct lib9p_srv_filehandle *fh = fidmap_get(req->afid);
 		if (!fh)
-			lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is not a valid FID");
+			lib9p_error(&ctx->ctx.basectx,
+			            LINUX_EACCES, "FID provided as auth-file is not a valid FID");
 		else if (fh->type != FH_AUTH)
-			lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is not an auth-file");
+			lib9p_error(&ctx->ctx.basectx,
+			            LINUX_EACCES, "FID provided as auth-file is not an auth-file");
 		else if (strcmp(fh->data.auth.uname, req->uname.utf8) != 0)
-			lib9p_errorf(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is for user=\"%s\" and cannot be used for user=\"%s\"",
+			lib9p_errorf(&ctx->ctx.basectx,
+			             LINUX_EACCES, "FID provided as auth-file is for user=\"%s\" and cannot be used for user=\"%s\"",
 			             fh->data.auth.uname, req->uname.utf8);
 		else if (strcmp(fh->data.auth.aname, req->aname.utf8) != 0)
-			lib9p_errorf(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file is for tree=\"%s\" and cannot be used for tree=\"%s\"",
+			lib9p_errorf(&ctx->ctx.basectx,
+			             LINUX_EACCES, "FID provided as auth-file is for tree=\"%s\" and cannot be used for tree=\"%s\"",
 			             fh->data.auth.aname, req->aname.utf8);
 		else if (!fh->data.auth.authenticated)
-			lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file has not completed authentication");
+			lib9p_error(&ctx->ctx.basectx,
+			            LINUX_EACCES, "FID provided as auth-file has not completed authentication");
 		fh->refcount--;
 		if (lib9p_ctx_has_error(&ctx->ctx))
 			return;
 		*/
-		lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "TODO: auth not implemented");
+		lib9p_error(&ctx->ctx.basectx,
+		            LINUX_EOPNOTSUPP, "TODO: auth not implemented");
 		return;
 	} else {
 		if (req->afid != LIB9P_NOFID) {
-			lib9p_error(&ctx->ctx, LINUX_EACCES, "FID provided as auth-file, but no auth-file is required");
+			lib9p_error(&ctx->ctx.basectx,
+			            LINUX_EACCES, "FID provided as auth-file, but no auth-file is required");
 			return;
 		}
 	}
 
 	if (fidmap_load(&ctx->parent_sess->fids, req->fid)) {
-		lib9p_error(&ctx->ctx, LINUX_EBADF, "FID already in use");
+		lib9p_error(&ctx->ctx.basectx,
+		            LINUX_EBADF, "FID already in use");
 		return;
 	}
 
-	struct lib9p_srv_file rootdir = ctx->parent_sess->parent_conn->parent_srv->rootdir(&subctx, req->aname.utf8);
-	if (lib9p_ctx_has_error(&ctx->ctx))
+	struct lib9p_srv_file rootdir = srv->rootdir(&ctx->ctx, req->aname.utf8);
+	if (lib9p_ctx_has_error(&ctx->ctx.basectx))
 		return;
 
-	struct lib9p_stat stat = rootdir.vtable.stat(&subctx, rootdir.impldata);
-	if (lib9p_ctx_has_error(&ctx->ctx)) {
+	struct lib9p_stat stat = rootdir.vtable.stat(&ctx->ctx, rootdir.impldata);
+	if (lib9p_ctx_has_error(&ctx->ctx.basectx)) {
 		if (rootdir.vtable.free)
-			rootdir.vtable.free(&subctx, rootdir.impldata);
+			rootdir.vtable.free(&ctx->ctx, rootdir.impldata);
 		return;
 	}
 
 	struct lib9p_srv_file *rootdir_ptr = fidmap_store(&ctx->parent_sess->fids, req->fid, rootdir);
 	if (!rootdir_ptr) {
-		lib9p_error(&ctx->ctx, LINUX_EMFILE, "too many open files");
+		lib9p_error(&ctx->ctx.basectx,
+		            LINUX_EMFILE, "too many open files");
 		if (rootdir.vtable.free)
-			rootdir.vtable.free(&subctx, rootdir.impldata);
+			rootdir.vtable.free(&ctx->ctx, rootdir.impldata);
 		return;
 	}
 
@@ -471,54 +500,93 @@ static void handle_Tattach(struct lib9p_req *ctx, struct lib9p_msg_Tattach *req,
 	return;
 }
 
-static void handle_Tflush(struct lib9p_req *ctx, struct lib9p_msg_Tflush *UNUSED(req), struct lib9p_msg_Rflush *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "flush not yet implemented");
+static void handle_Tflush(struct _lib9p_srv_req *ctx,
+                          struct lib9p_msg_Tflush *UNUSED(req),
+                          struct lib9p_msg_Rflush *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "flush not yet implemented");
 }
 
-static void handle_Twalk(struct lib9p_req *ctx, struct lib9p_msg_Twalk *UNUSED(req), struct lib9p_msg_Rwalk *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "walk not yet implemented");
+static void handle_Twalk(struct _lib9p_srv_req *ctx,
+                         struct lib9p_msg_Twalk *UNUSED(req),
+                         struct lib9p_msg_Rwalk *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "walk not yet implemented");
 }
 
-static void handle_Topen(struct lib9p_req *ctx, struct lib9p_msg_Topen *UNUSED(req), struct lib9p_msg_Ropen *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "open not yet implemented");
+static void handle_Topen(struct _lib9p_srv_req *ctx,
+                         struct lib9p_msg_Topen *UNUSED(req),
+                         struct lib9p_msg_Ropen *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "open not yet implemented");
 }
 
-static void handle_Tcreate(struct lib9p_req *ctx, struct lib9p_msg_Tcreate *UNUSED(req), struct lib9p_msg_Rcreate *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "create not yet implemented");
+static void handle_Tcreate(struct _lib9p_srv_req *ctx,
+                           struct lib9p_msg_Tcreate *UNUSED(req),
+                           struct lib9p_msg_Rcreate *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "create not yet implemented");
 }
 
-static void handle_Tread(struct lib9p_req *ctx, struct lib9p_msg_Tread *UNUSED(req), struct lib9p_msg_Rread *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "read not yet implemented");
+static void handle_Tread(struct _lib9p_srv_req *ctx,
+                         struct lib9p_msg_Tread *UNUSED(req),
+                         struct lib9p_msg_Rread *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "read not yet implemented");
 }
 
-static void handle_Twrite(struct lib9p_req *ctx, struct lib9p_msg_Twrite *UNUSED(req), struct lib9p_msg_Rwrite *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "write not yet implemented");
+static void handle_Twrite(struct _lib9p_srv_req *ctx,
+                          struct lib9p_msg_Twrite *UNUSED(req),
+                          struct lib9p_msg_Rwrite *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "write not yet implemented");
 }
 
-static void handle_Tclunk(struct lib9p_req *ctx, struct lib9p_msg_Tclunk *UNUSED(req), struct lib9p_msg_Rclunk *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "clunk not yet implemented");
+static void handle_Tclunk(struct _lib9p_srv_req *ctx,
+                          struct lib9p_msg_Tclunk *UNUSED(req),
+                          struct lib9p_msg_Rclunk *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "clunk not yet implemented");
 }
 
-static void handle_Tremove(struct lib9p_req *ctx, struct lib9p_msg_Tremove *UNUSED(req), struct lib9p_msg_Rremove *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "remove not yet implemented");
+static void handle_Tremove(struct _lib9p_srv_req *ctx,
+                           struct lib9p_msg_Tremove *UNUSED(req),
+                           struct lib9p_msg_Rremove *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "remove not yet implemented");
 }
 
-static void handle_Tstat(struct lib9p_req *ctx, struct lib9p_msg_Tstat *UNUSED(req), struct lib9p_msg_Rstat *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "stat not yet implemented");
+static void handle_Tstat(struct _lib9p_srv_req *ctx,
+                         struct lib9p_msg_Tstat *UNUSED(req),
+                         struct lib9p_msg_Rstat *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "stat not yet implemented");
 }
 
-static void handle_Twstat(struct lib9p_req *ctx, struct lib9p_msg_Twstat *UNUSED(req), struct lib9p_msg_Rwstat *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "wstat not yet implemented");
+static void handle_Twstat(struct _lib9p_srv_req *ctx,
+                          struct lib9p_msg_Twstat *UNUSED(req),
+                          struct lib9p_msg_Rwstat *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "wstat not yet implemented");
 }
 
-static void handle_Tsession(struct lib9p_req *ctx, struct lib9p_msg_Tsession *UNUSED(req), struct lib9p_msg_Rsession *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "session not yet implemented");
+static void handle_Tsession(struct _lib9p_srv_req *ctx,
+                            struct lib9p_msg_Tsession *UNUSED(req),
+                            struct lib9p_msg_Rsession *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "session not yet implemented");
 }
 
-static void handle_Tsread(struct lib9p_req *ctx, struct lib9p_msg_Tsread *UNUSED(req), struct lib9p_msg_Rsread *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "sread not yet implemented");
+static void handle_Tsread(struct _lib9p_srv_req *ctx,
+                          struct lib9p_msg_Tsread *UNUSED(req),
+                          struct lib9p_msg_Rsread *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "sread not yet implemented");
 }
 
-static void handle_Tswrite(struct lib9p_req *ctx, struct lib9p_msg_Tswrite *UNUSED(req), struct lib9p_msg_Rswrite *UNUSED(resp)) {
-	lib9p_error(&ctx->ctx, LINUX_EOPNOTSUPP, "swrite not yet implemented");
+static void handle_Tswrite(struct _lib9p_srv_req *ctx,
+                           struct lib9p_msg_Tswrite *UNUSED(req),
+                           struct lib9p_msg_Rswrite *UNUSED(resp)) {
+	lib9p_error(&ctx->ctx.basectx,
+	            LINUX_EOPNOTSUPP, "swrite not yet implemented");
 }