struct handle_input *ctx = (struct handle_input *) param;
OVERLAPPED ovl, *povl;
HANDLE oev;
- int readret, readlen;
+ int readret, readlen, finished;
if (ctx->flags & HANDLE_FLAG_OVERLAPPED) {
povl = &ovl;
(ctx->flags & HANDLE_FLAG_IGNOREEOF))
continue;
+ /*
+ * If we just set ctx->len to 0, that means the read operation
+ * has returned end-of-file. Telling that to the main thread
+ * will cause it to set its 'defunct' flag and dispose of the
+ * handle structure at the next opportunity, in which case we
+ * mustn't touch ctx at all after the SetEvent. (Hence we do
+ * even _this_ check before the SetEvent.)
+ */
+ finished = (ctx->len == 0);
+
SetEvent(ctx->ev_to_main);
- if (!ctx->len) {
- /*
- * The read operation has returned end-of-file. Telling
- * that to the main thread will cause it to set its
- * 'defunct' flag and dispose of the handle structure at
- * the next opportunity, so we must not touch ctx at all
- * after this.
- */
+ if (finished)
break;
- }
WaitForSingleObject(ctx->ev_from_main, INFINITE);
if (ctx->done) {
struct handle *a = (struct handle *)av;
struct handle *b = (struct handle *)bv;
- if ((unsigned)a->u.g.ev_to_main < (unsigned)b->u.g.ev_to_main)
+ if ((uintptr_t)a->u.g.ev_to_main < (uintptr_t)b->u.g.ev_to_main)
return -1;
- else if ((unsigned)a->u.g.ev_to_main > (unsigned)b->u.g.ev_to_main)
+ else if ((uintptr_t)a->u.g.ev_to_main > (uintptr_t)b->u.g.ev_to_main)
return +1;
else
return 0;
HANDLE *a = (HANDLE *)av;
struct handle *b = (struct handle *)bv;
- if ((unsigned)*a < (unsigned)b->u.g.ev_to_main)
+ if ((uintptr_t)*a < (uintptr_t)b->u.g.ev_to_main)
return -1;
- else if ((unsigned)*a > (unsigned)b->u.g.ev_to_main)
+ else if ((uintptr_t)*a > (uintptr_t)b->u.g.ev_to_main)
return +1;
else
return 0;
void handle_free(struct handle *h)
{
- /*
- * If the handle is currently busy, we cannot immediately free
- * it. Instead we must wait until it's finished its current
- * operation, because otherwise the subthread will write to
- * invalid memory after we free its context from under it.
- */
assert(h && !h->u.g.moribund);
- if (h->u.g.busy) {
- /*
- * Just set the moribund flag, which will be noticed next
- * time an operation completes.
+ if (h->u.g.busy && h->type != HT_FOREIGN) {
+ /*
+ * If the handle is currently busy, we cannot immediately free
+ * it, because its subthread is in the middle of something.
+ * (Exception: foreign handles don't have a subthread.)
+ *
+ * Instead we must wait until it's finished its current
+ * operation, because otherwise the subthread will write to
+ * invalid memory after we free its context from under it. So
+ * we set the moribund flag, which will be noticed next time
+ * an operation completes.
*/
h->u.g.moribund = TRUE;
} else if (h->u.g.defunct) {