X-Git-Url: http://git.ozlabs.org/?p=ccan;a=blobdiff_plain;f=ccan%2Fio%2Fio.c;h=8e2695292bb158a15130c0754dbbee94ac2bfb71;hp=54ba7da529ec433661163f2d01fb4ab335562fa8;hb=12e924346b342c61219a3fdc57eb6b00a27f1cd1;hpb=02ae136a997a5e7cc3bb9210167a066b9f169a7b diff --git a/ccan/io/io.c b/ccan/io/io.c index 54ba7da5..8e269529 100644 --- a/ccan/io/io.c +++ b/ccan/io/io.c @@ -8,7 +8,6 @@ #include #include #include -#include #include #include @@ -25,8 +24,6 @@ bool io_plan_nodebug; struct io_conn *current; /* User-defined function to select which connection(s) to debug. */ bool (*io_debug_conn)(struct io_conn *conn); -/* Set when we wake up an connection we are debugging. */ -bool io_debug_wakeup; struct io_plan io_debug(struct io_plan plan) { @@ -37,21 +34,12 @@ struct io_plan io_debug(struct io_plan plan) return plan; } - if (!current || !doing_debug_on(current)) { - if (!io_debug_wakeup) - return plan; - } + if (!current || !doing_debug_on(current)) + return plan; - io_debug_wakeup = false; current->plan = plan; backend_plan_changed(current); - /* If it closed, close duplex. */ - if (!current->plan.next && current->duplex) { - current->duplex->plan = io_close_(); - backend_plan_changed(current->duplex); - } - /* Call back into the loop immediately. */ io_loop_return = do_io_loop(&ready); @@ -75,7 +63,7 @@ struct io_plan io_debug(struct io_plan plan) /* Return a do-nothing plan, so backend_plan_changed in * io_ready doesn't do anything (it's already been called). */ - return io_idle_(); + return io_wait_(NULL, (void *)1, NULL); } int io_debug_io(int ret) @@ -114,22 +102,12 @@ int io_debug_io(int ret) return 2; } -static void debug_io_wake(struct io_conn *conn) -{ - /* We want linear if we wake a debugged connection, too. */ - if (io_debug_conn && io_debug_conn(conn)) - io_debug_wakeup = true; -} - /* Counterpart to io_plan_no_debug(), called in macros in io.h */ static void io_plan_debug_again(void) { io_plan_nodebug = false; } #else -static void debug_io_wake(struct io_conn *conn) -{ -} static void io_plan_debug_again(void) { } @@ -220,7 +198,7 @@ struct io_conn *io_duplex_(struct io_conn *old, struct io_plan plan) return conn; } -bool io_timeout_(struct io_conn *conn, struct timespec ts, +bool io_timeout_(struct io_conn *conn, struct timerel t, struct io_plan (*cb)(struct io_conn *, void *), void *arg) { assert(cb); @@ -234,10 +212,30 @@ bool io_timeout_(struct io_conn *conn, struct timespec ts, conn->timeout->next = cb; conn->timeout->next_arg = arg; - backend_add_timeout(conn, ts); + backend_add_timeout(conn, t); return true; } +/* Always done: call the next thing. */ +static int do_always(int fd, struct io_plan *plan) +{ + return 1; +} + +struct io_plan io_always_(struct io_plan (*cb)(struct io_conn *, void *), + void *arg) +{ + struct io_plan plan; + + assert(cb); + plan.io = do_always; + plan.next = cb; + plan.next_arg = arg; + plan.pollflag = POLLALWAYS; + + return plan; +} + /* Returns true if we're finished. */ static int do_write(int fd, struct io_plan *plan) { @@ -258,6 +256,10 @@ struct io_plan io_write_(const void *data, size_t len, struct io_plan plan; assert(cb); + + if (len == 0) + return io_always_(cb, arg); + plan.u1.const_vp = data; plan.u2.s = len; plan.io = do_write; @@ -287,11 +289,16 @@ struct io_plan io_read_(void *data, size_t len, struct io_plan plan; assert(cb); + + if (len == 0) + return io_always_(cb, arg); + plan.u1.cp = data; plan.u2.s = len; plan.io = do_read; plan.next = cb; plan.next_arg = arg; + plan.pollflag = POLLIN; return plan; @@ -315,6 +322,10 @@ struct io_plan io_read_partial_(void *data, size_t *len, struct io_plan plan; assert(cb); + + if (*len == 0) + return io_always_(cb, arg); + plan.u1.cp = data; plan.u2.vp = len; plan.io = do_read_partial; @@ -343,6 +354,10 @@ struct io_plan io_write_partial_(const void *data, size_t *len, struct io_plan plan; assert(cb); + + if (*len == 0) + return io_always_(cb, arg); + plan.u1.const_vp = data; plan.u2.vp = len; plan.io = do_write_partial; @@ -370,10 +385,13 @@ static int do_connect(int fd, struct io_plan *plan) if (err == 0) { /* Restore blocking if it was initially. */ - fcntl(fd, F_SETFD, plan->u1.s); + fcntl(fd, F_SETFL, plan->u1.s); return 1; - } - return 0; + } else if (err == EINPROGRESS) + return 0; + + errno = err; + return -1; } struct io_plan io_connect_(int fd, const struct addrinfo *addr, @@ -388,8 +406,8 @@ struct io_plan io_connect_(int fd, const struct addrinfo *addr, plan.next_arg = arg; /* Save old flags, set nonblock if not already. */ - plan.u1.s = fcntl(fd, F_GETFD); - fcntl(fd, F_SETFD, plan.u1.s | O_NONBLOCK); + plan.u1.s = fcntl(fd, F_GETFL); + fcntl(fd, F_SETFL, plan.u1.s | O_NONBLOCK); /* Immediate connect can happen. */ if (connect(fd, addr->ai_addr, addr->ai_addrlen) == 0) { @@ -406,41 +424,34 @@ struct io_plan io_connect_(int fd, const struct addrinfo *addr, return plan; } -struct io_plan io_idle_(void) +struct io_plan io_wait_(const void *wait, + struct io_plan (*cb)(struct io_conn *, void*), + void *arg) { struct io_plan plan; + assert(cb); plan.pollflag = 0; plan.io = NULL; - /* Never called (overridden by io_wake), but NULL means closing */ - plan.next = (void *)io_idle_; + plan.next = cb; + plan.next_arg = arg; + + plan.u1.const_vp = wait; return plan; } -bool io_is_idle(const struct io_conn *conn) +void io_wake(const void *wait) { - return conn->plan.io == NULL; + backend_wait_changed(wait); } -void io_wake_(struct io_conn *conn, struct io_plan plan) - +void io_ready(struct io_conn *conn) { - io_plan_debug_again(); - - /* It might be closing, but we haven't called its finish() yet. */ + /* Beware io_close_other! */ if (!conn->plan.next) return; - /* It was idle, right? */ - assert(!conn->plan.io); - conn->plan = plan; - backend_plan_changed(conn); - debug_io_wake(conn); -} - -void io_ready(struct io_conn *conn) -{ set_current(conn); switch (conn->plan.io(conn->fd.fd, &conn->plan)) { case -1: /* Failure means a new plan: close up. */ @@ -460,14 +471,6 @@ void io_ready(struct io_conn *conn) backend_plan_changed(conn); } set_current(NULL); - - /* If it closed, close duplex if not already */ - if (!conn->plan.next && conn->duplex && conn->duplex->plan.next) { - set_current(conn->duplex); - conn->duplex->plan = io_close(); - backend_plan_changed(conn->duplex); - set_current(NULL); - } } /* Close the connection, we're done. */ @@ -488,6 +491,15 @@ struct io_plan io_close_cb(struct io_conn *conn, void *arg) return io_close(); } +void io_close_other(struct io_conn *conn) +{ + /* Don't close if already closing! */ + if (conn->plan.next) { + conn->plan = io_close_(); + backend_plan_changed(conn); + } +} + /* Exit the loop, returning this (non-NULL) arg. */ struct io_plan io_break_(void *ret, struct io_plan plan) { @@ -499,6 +511,16 @@ struct io_plan io_break_(void *ret, struct io_plan plan) return plan; } +static struct io_plan io_never_called(struct io_conn *conn, void *arg) +{ + abort(); +} + +struct io_plan io_never(void) +{ + return io_always_(io_never_called, NULL); +} + int io_conn_fd(const struct io_conn *conn) { return conn->fd.fd;