Merge branch 'lukeshu/9p-fix-flush'

1 files changed, 59 insertions, 92 deletions

diff --git a/libcr_ipc/chan.c b/libcr_ipc/chan.c
index 6cbe890..b7ecfc8 100644
--- a/libcr_ipc/chan.c
+++ b/libcr_ipc/chan.c
@@ -4,60 +4,22 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 
-#include <alloca.h>  /* for alloca() */
 #include <string.h>  /* for memcpy() */
 
 #include <libcr/coroutine.h> /* for cid_t, cr_* */
 #include <libmisc/assert.h>
 #include <libmisc/rand.h>
 
+#define IMPLEMENTATION_FOR_LIBCR_IPC_CHAN_H YES
 #include <libcr_ipc/chan.h>
 
-/* base channels **************************************************************/
-
-struct cr_chan_waiter {
+struct _cr_select_waiter {
 	cid_t                            cid;
-	void                            *val_ptr;
-	void                             (*dequeue)(void *, size_t);
-	void                            *dequeue_arg1;
-	size_t                           dequeue_arg2;
-};
-DLIST_DECLARE_NODE(_cr_chan_waiter_list, struct cr_chan_waiter);
-
-void cr_chan_dequeue(void *_ch, size_t) {
-	struct _cr_chan *ch = _ch;
-	dlist_pop_from_front(&ch->waiters);
-}
-
-void _cr_chan_xfer(enum _cr_chan_waiter_typ self_typ, struct _cr_chan *ch, void *val_ptr, size_t val_size) {
-	assert(ch);
-	assert(val_ptr);
+	struct _cr_select_arg_list_node *arg_vec;
+	size_t                           arg_cnt;
 
-	if (ch->waiters.front && ch->waiter_typ != self_typ) { /* non-blocking fast-path */
-		/* Copy.  */
-		struct _cr_chan_waiter_list_node *front = ch->waiters.front;
-		if (self_typ == _CR_CHAN_SENDER)
-			memcpy(front->val.val_ptr, val_ptr, val_size);
-		else
-			memcpy(val_ptr, front->val.val_ptr, val_size);
-		cr_unpause(front->val.cid);
-		front->val.dequeue(front->val.dequeue_arg1,
-		                   front->val.dequeue_arg2);
-		cr_yield();
-	} else { /* blocking slow-path */
-		struct _cr_chan_waiter_list_node self = { .val = {
-			.cid          = cr_getcid(),
-			.val_ptr      = val_ptr,
-			.dequeue      = cr_chan_dequeue,
-			.dequeue_arg1 = ch,
-		}};
-		dlist_push_to_rear(&ch->waiters, &self);
-		ch->waiter_typ = self_typ;
-		cr_pause_and_yield();
-	}
-}
-
-/* select *********************************************************************/
+	size_t                           ret;
+};
 
 enum cr_select_class {
 	CR_SELECT_CLASS_DEFAULT,
@@ -65,40 +27,26 @@ enum cr_select_class {
 	CR_SELECT_CLASS_NONBLOCK,
 };
 
-struct cr_select_waiters {
-	size_t                                   cnt;
-	struct cr_select_arg                    *args;
-	struct _cr_chan_waiter_list_node        *nodes;
-};
-
-static inline enum cr_select_class cr_select_getclass(struct cr_select_arg arg) {
-	switch (arg.op) {
+static inline enum cr_select_class cr_select_getclass(struct _cr_select_arg *arg) {
+	switch (arg->op) {
 	case _CR_SELECT_OP_RECV:
-		if (arg.ch->waiters.front && arg.ch->waiter_typ == _CR_CHAN_SENDER)
+		if (arg->ch->waiters.front && arg->ch->waiters.front->val.op == _CR_SELECT_OP_SEND)
 			return CR_SELECT_CLASS_NONBLOCK;
 		else
 			return CR_SELECT_CLASS_BLOCKING;
 	case _CR_SELECT_OP_SEND:
-		if (arg.ch->waiters.front && arg.ch->waiter_typ == _CR_CHAN_RECVER)
+		if (arg->ch->waiters.front && arg->ch->waiters.front->val.op == _CR_SELECT_OP_RECV)
 			return CR_SELECT_CLASS_NONBLOCK;
 		else
 			return CR_SELECT_CLASS_BLOCKING;
 	case _CR_SELECT_OP_DEFAULT:
 		return CR_SELECT_CLASS_DEFAULT;
 	default:
-		assert_notreached("invalid arg.op");
+		assert_notreached("invalid arg->op");
 	}
 }
 
-void cr_select_dequeue(void *_waiters, size_t idx) {
-	struct cr_select_waiters *waiters = _waiters;
-	for (size_t i = 0; i < waiters->cnt; i++)
-		dlist_remove(&(waiters->args[i].ch->waiters),
-		             &(waiters->nodes[i]));
-	waiters->cnt = idx;
-}
-
-size_t cr_select_v(size_t arg_cnt, struct cr_select_arg arg_vec[]) {
+size_t cr_select_v(size_t arg_cnt, struct _cr_select_arg_list_node arg_vec[]) {
 	size_t  cnt_blocking = 0;
 	size_t  cnt_nonblock = 0;
 	size_t  cnt_default  = 0;
@@ -108,7 +56,7 @@ size_t cr_select_v(size_t arg_cnt, struct cr_select_arg arg_vec[]) {
 	cr_assert_in_coroutine();
 
 	for (size_t i = 0; i < arg_cnt; i++) {
-		switch (cr_select_getclass(arg_vec[i])) {
+		switch (cr_select_getclass(&arg_vec[i].val)) {
 		case CR_SELECT_CLASS_BLOCKING:
 			cnt_blocking++;
 			break;
@@ -122,46 +70,65 @@ size_t cr_select_v(size_t arg_cnt, struct cr_select_arg arg_vec[]) {
 	}
 
 	if (cnt_nonblock) {
-		size_t choice = rand_uint63n(cnt_nonblock);
-		for (size_t i = 0, seen = 0; i < arg_cnt; i++) {
-			if (cr_select_getclass(arg_vec[i]) == CR_SELECT_CLASS_NONBLOCK) {
-				if (seen == choice) {
-					_cr_chan_xfer(arg_vec[i].op == _CR_SELECT_OP_RECV
-					              ? _CR_CHAN_RECVER
-					              : _CR_CHAN_SENDER,
-					              arg_vec[i].ch,
-					              arg_vec[i].val_ptr,
-					              arg_vec[i].val_siz);
-					return i;
-				}
+		size_t choice_among_nonblock = rand_uint63n(cnt_nonblock);
+		size_t choice_among_all = arg_cnt;
+		for (size_t i = 0, seen = 0; i < choice_among_all; i++) {
+			if (cr_select_getclass(&arg_vec[i].val) == CR_SELECT_CLASS_NONBLOCK) {
+				if (seen == choice_among_nonblock)
+					choice_among_all = i;
 				seen++;
 			}
 		}
-		assert_notreached("should have returned from inside for() loop");
+		assert(choice_among_all < arg_cnt);
+
+		struct _cr_select_arg *this = &arg_vec[choice_among_all].val;
+		assert(this->ch->waiters.front);
+		struct _cr_select_arg *other = &this->ch->waiters.front->val;
+		assert(this->val_siz == other->val_siz);
+		assert(this->ch == other->ch);
+		switch (this->op) {
+		case _CR_SELECT_OP_SEND:
+			assert(other->op == _CR_SELECT_OP_RECV);
+			memcpy(other->val_ptr, this->val_ptr, this->val_siz);
+			break;
+		case _CR_SELECT_OP_RECV:
+			assert(other->op == _CR_SELECT_OP_SEND);
+			memcpy(this->val_ptr, other->val_ptr, this->val_siz);
+			break;
+		case _CR_SELECT_OP_DEFAULT:
+			assert_notreached("_CR_SELECT_OP_DEFAULT is not CR_SELECT_CLASS_NONBLOCK");
+		}
+		struct _cr_select_waiter *waiter = other->waiter;
+		for (size_t i = 0; i < waiter->arg_cnt; i++) {
+			waiter->arg_vec[i].val.ch->nwaiters--;
+			dlist_remove(&waiter->arg_vec[i].val.ch->waiters, &waiter->arg_vec[i]);
+			if (&waiter->arg_vec[i].val == other)
+				waiter->ret = i;
+		}
+		cr_unpause(waiter->cid);
+		cr_yield();
+		return choice_among_all;
 	}
 
 	if (cnt_default) {
 		for (size_t i = 0; i < arg_cnt; i++)
-			if (cr_select_getclass(arg_vec[i]) == CR_SELECT_CLASS_DEFAULT)
+			if (cr_select_getclass(&arg_vec[i].val) == CR_SELECT_CLASS_DEFAULT)
 				return i;
 		assert_notreached("should have returned from inside for() loop");
 	}
 
-	struct cr_select_waiters waiters = {
-		.cnt   = arg_cnt,
-		.args  = arg_vec,
-		.nodes = alloca(sizeof(struct cr_chan_waiter) * arg_cnt),
+	assert(cnt_blocking && cnt_blocking == arg_cnt);
+
+	struct _cr_select_waiter waiter = {
+		.cid     = cr_getcid(),
+		.arg_vec = arg_vec,
+		.arg_cnt = arg_cnt,
 	};
 	for (size_t i = 0; i < arg_cnt; i++) {
-		waiters.nodes[i] = (struct _cr_chan_waiter_list_node){ .val = {
-			.cid          = cr_getcid(),
-			.val_ptr      = arg_vec[i].val_ptr,
-			.dequeue      = cr_select_dequeue,
-			.dequeue_arg1 = &waiters,
-			.dequeue_arg2 = i,
-		}};
-		dlist_push_to_rear(&arg_vec[i].ch->waiters, &waiters.nodes[i]);
+		arg_vec[i].val.waiter = &waiter;
+		arg_vec[i].val.ch->nwaiters++;
+		dlist_push_to_rear(&arg_vec[i].val.ch->waiters, &arg_vec[i]);
 	}
 	cr_pause_and_yield();
-	return waiters.cnt;
+	return waiter.ret;
 }