X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Fio%2Fio.c;h=68b95e82467194f13e87302e907cda5020fe37db;hp=7dbb9c5a3962d3a802bf1aae502ceeda4bb1b685;hb=3f642347378afc9e1db1768d88c9f5b2baffe9ba;hpb=8d94c52a7d6a51fd3a95734b2b4c7daa8c687d91 diff --git a/ccan/io/io.c b/ccan/io/io.c index 7dbb9c5a..68b95e82 100644 --- a/ccan/io/io.c +++ b/ccan/io/io.c @@ -14,6 +14,8 @@ void *io_loop_return; +struct io_plan io_conn_freed; + struct io_listener *io_new_listener_(const tal_t *ctx, int fd, struct io_plan *(*init)(struct io_conn *, void *), @@ -35,8 +37,6 @@ struct io_listener *io_new_listener_(const tal_t *ctx, int fd, void io_close_listener(struct io_listener *l) { - close(l->fd.fd); - del_listener(l); tal_free(l); } @@ -45,7 +45,8 @@ static struct io_plan *io_never_called(struct io_conn *conn, void *arg) abort(); } -static void next_plan(struct io_conn *conn, struct io_plan *plan) +/* Returns false if conn was freed. */ +static bool next_plan(struct io_conn *conn, struct io_plan *plan) { struct io_plan *(*next)(struct io_conn *, void *arg); @@ -57,6 +58,9 @@ static void next_plan(struct io_conn *conn, struct io_plan *plan) plan = next(conn, plan->next_arg); + if (plan == &io_conn_freed) + return false; + /* It should have set a plan inside this conn (or duplex) */ assert(plan == &conn->plan[IO_IN] || plan == &conn->plan[IO_OUT] @@ -65,6 +69,19 @@ static void next_plan(struct io_conn *conn, struct io_plan *plan) || conn->plan[IO_OUT].status != IO_UNSET); backend_new_plan(conn); + return true; +} + +static void set_blocking(int fd, bool block) +{ + int flags = fcntl(fd, F_GETFL); + + if (block) + flags &= ~O_NONBLOCK; + else + flags |= O_NONBLOCK; + + fcntl(fd, F_SETFL, flags); } struct io_conn *io_new_conn_(const tal_t *ctx, int fd, @@ -80,18 +97,21 @@ struct io_conn *io_new_conn_(const tal_t *ctx, int fd, conn->fd.fd = fd; conn->finish = NULL; conn->finish_arg = NULL; - conn->list = NULL; - conn->debug = false; + list_node_init(&conn->always); if (!add_conn(conn)) return tal_free(conn); + /* Keep our I/O async. */ + set_blocking(fd, false); + /* We start with out doing nothing, and in doing our init. */ conn->plan[IO_OUT].status = IO_UNSET; conn->plan[IO_IN].next = init; conn->plan[IO_IN].next_arg = arg; - next_plan(conn, &conn->plan[IO_IN]); + if (!next_plan(conn, &conn->plan[IO_IN])) + return NULL; return conn; } @@ -275,8 +295,6 @@ static int do_connect(int fd, struct io_plan_arg *arg) return -1; if (err == 0) { - /* Restore blocking if it was initially. */ - fcntl(fd, F_SETFL, arg->u1.s); return 1; } else if (err == EINPROGRESS) return 0; @@ -289,21 +307,21 @@ struct io_plan *io_connect_(struct io_conn *conn, const struct addrinfo *addr, struct io_plan *(*next)(struct io_conn *, void *), void *next_arg) { - struct io_plan_arg *arg = io_plan_arg(conn, IO_IN); int fd = io_conn_fd(conn); - /* Save old flags, set nonblock if not already. */ - arg->u1.s = fcntl(fd, F_GETFL); - fcntl(fd, F_SETFL, arg->u1.s | O_NONBLOCK); + /* We don't actually need the arg, but we need it polling. */ + io_plan_arg(conn, IO_OUT); + + /* Note that io_new_conn() will make fd O_NONBLOCK */ /* Immediate connect can happen. */ if (connect(fd, addr->ai_addr, addr->ai_addrlen) == 0) - return set_always(conn, IO_IN, next, next_arg); + return set_always(conn, IO_OUT, next, next_arg); if (errno != EINPROGRESS) return io_close(conn); - return io_set_plan(conn, IO_IN, do_connect, next, next_arg); + return io_set_plan(conn, IO_OUT, do_connect, next, next_arg); } static struct io_plan *io_wait_dir(struct io_conn *conn, @@ -342,24 +360,20 @@ void io_wake(const void *wait) backend_wake(wait); } -static int do_plan(struct io_conn *conn, struct io_plan *plan) +/* Returns false if this has been freed. */ +static bool do_plan(struct io_conn *conn, struct io_plan *plan) { - /* Someone else might have called io_close() on us. */ - if (plan->status == IO_CLOSING) - return -1; - /* We shouldn't have polled for this event if this wasn't true! */ assert(plan->status == IO_POLLING); switch (plan->io(conn->fd.fd, &plan->arg)) { case -1: io_close(conn); - return -1; + return false; case 0: - return 0; + return true; case 1: - next_plan(conn, plan); - return 1; + return next_plan(conn, plan); default: /* IO should only return -1, 0 or 1 */ abort(); @@ -369,7 +383,8 @@ static int do_plan(struct io_conn *conn, struct io_plan *plan) void io_ready(struct io_conn *conn, int pollflags) { if (pollflags & POLLIN) - do_plan(conn, &conn->plan[IO_IN]); + if (!do_plan(conn, &conn->plan[IO_IN])) + return; if (pollflags & POLLOUT) do_plan(conn, &conn->plan[IO_OUT]); @@ -378,7 +393,8 @@ void io_ready(struct io_conn *conn, int pollflags) void io_do_always(struct io_conn *conn) { if (conn->plan[IO_IN].status == IO_ALWAYS) - next_plan(conn, &conn->plan[IO_IN]); + if (!next_plan(conn, &conn->plan[IO_IN])) + return; if (conn->plan[IO_OUT].status == IO_ALWAYS) next_plan(conn, &conn->plan[IO_OUT]); @@ -396,15 +412,8 @@ void io_do_wakeup(struct io_conn *conn, enum io_direction dir) /* Close the connection, we're done. */ struct io_plan *io_close(struct io_conn *conn) { - /* Already closing? Don't close twice. */ - if (conn->plan[IO_IN].status == IO_CLOSING) - return &conn->plan[IO_IN]; - - conn->plan[IO_IN].status = conn->plan[IO_OUT].status = IO_CLOSING; - conn->plan[IO_IN].arg.u1.s = errno; - backend_new_closing(conn); - - return io_set_plan(conn, IO_IN, NULL, NULL, NULL); + tal_free(conn); + return &io_conn_freed; } struct io_plan *io_close_cb(struct io_conn *conn, void *next_arg) @@ -412,6 +421,14 @@ struct io_plan *io_close_cb(struct io_conn *conn, void *next_arg) return io_close(conn); } +struct io_plan *io_close_taken_fd(struct io_conn *conn) +{ + set_blocking(conn->fd.fd, true); + + cleanup_conn_without_close(conn); + return io_close(conn); +} + /* Exit the loop, returning this (non-NULL) arg. */ void io_break(const void *ret) { @@ -429,43 +446,17 @@ int io_conn_fd(const struct io_conn *conn) return conn->fd.fd; } -void io_duplex_prepare(struct io_conn *conn) -{ - assert(conn->plan[IO_IN].status == IO_UNSET); - assert(conn->plan[IO_OUT].status == IO_UNSET); - - /* We can't sync debug until we've set both: io_wait() and io_always - * can't handle it. */ - conn->debug_saved = conn->debug; - conn->debug = false; -} - -struct io_plan *io_duplex_(struct io_plan *in_plan, struct io_plan *out_plan) +struct io_plan *io_duplex(struct io_conn *conn, + struct io_plan *in_plan, struct io_plan *out_plan) { - struct io_conn *conn; - + assert(conn == container_of(in_plan, struct io_conn, plan[IO_IN])); /* in_plan must be conn->plan[IO_IN], out_plan must be [IO_OUT] */ assert(out_plan == in_plan + 1); - - /* Restore debug. */ - conn = container_of(in_plan, struct io_conn, plan[IO_IN]); - conn->debug = conn->debug_saved; - - /* Now set the plans again, to invoke sync debug. */ - io_set_plan(conn, IO_OUT, - out_plan->io, out_plan->next, out_plan->next_arg); - io_set_plan(conn, IO_IN, - in_plan->io, in_plan->next, in_plan->next_arg); - return out_plan + 1; } struct io_plan *io_halfclose(struct io_conn *conn) { - /* Already closing? Don't close twice. */ - if (conn->plan[IO_IN].status == IO_CLOSING) - return &conn->plan[IO_IN]; - /* Both unset? OK. */ if (conn->plan[IO_IN].status == IO_UNSET && conn->plan[IO_OUT].status == IO_UNSET) @@ -488,42 +479,7 @@ struct io_plan *io_set_plan(struct io_conn *conn, enum io_direction dir, plan->io = io; plan->next = next; plan->next_arg = next_arg; - assert(plan->status == IO_CLOSING || next != NULL); - - if (!conn->debug) - return plan; - - if (io_loop_return) { - io_debug_complete(conn); - return plan; - } - - switch (plan->status) { - case IO_POLLING: - while (do_plan(conn, plan) == 0); - break; - /* Shouldn't happen, since you said you did plan! */ - case IO_UNSET: - abort(); - case IO_ALWAYS: - /* If other one is ALWAYS, leave in list! */ - if (conn->plan[!dir].status != IO_ALWAYS) - remove_from_always(conn); - next_plan(conn, plan); - break; - case IO_WAITING: - case IO_CLOSING: - io_debug_complete(conn); - } + assert(next != NULL); return plan; } - -void io_set_debug(struct io_conn *conn, bool debug) -{ - conn->debug = debug; -} - -void io_debug_complete(struct io_conn *conn) -{ -}