X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;ds=sidebyside;f=ccan%2Fio%2Fio.c;h=f7b46faaa5f8a5da64a07a9dc60caa67dd78d8fc;hb=42762758d98feb08b861361b7f695de2cad26b07;hp=ec4d4fabbc19df27e67059c652787df4e37f99eb;hpb=0998955055e45ef980a2dfdbd302142269abdd26;p=ccan diff --git a/ccan/io/io.c b/ccan/io/io.c index ec4d4fab..f7b46faa 100644 --- a/ccan/io/io.c +++ b/ccan/io/io.c @@ -8,6 +8,7 @@ #include #include #include +#include void *io_loop_return; @@ -24,9 +25,9 @@ struct io_listener *io_new_listener_(int fd, l->fd.listener = true; l->fd.fd = fd; - l->fd.next = start; - l->fd.finish = finish; - l->fd.finish_arg = l->fd.next_arg = arg; + l->next = start; + l->finish = finish; + l->conn_arg = arg; if (!add_listener(l)) { free(l); return NULL; @@ -53,10 +54,11 @@ struct io_conn *io_new_conn_(int fd, conn->fd.listener = false; conn->fd.fd = fd; - conn->fd.next = start; - conn->fd.finish = finish; - conn->fd.finish_arg = conn->fd.next_arg = arg; - conn->state = NEXT; + conn->next = start; + conn->finish = finish; + conn->finish_arg = conn->next_arg = arg; + conn->pollflag = 0; + conn->state = IO_NEXT; conn->duplex = NULL; conn->timeout = NULL; if (!add_conn(conn)) { @@ -81,10 +83,11 @@ struct io_conn *io_duplex_(struct io_conn *old, conn->fd.listener = false; conn->fd.fd = old->fd.fd; - conn->fd.next = start; - conn->fd.finish = finish; - conn->fd.finish_arg = conn->fd.next_arg = arg; - conn->state = NEXT; + conn->next = start; + conn->finish = finish; + conn->finish_arg = conn->next_arg = arg; + conn->pollflag = 0; + conn->state = IO_NEXT; conn->duplex = old; conn->timeout = NULL; if (!add_duplex(conn)) { @@ -116,6 +119,20 @@ bool io_timeout_(struct io_conn *conn, struct timespec ts, return true; } +static enum io_result do_write(struct io_conn *conn) +{ + ssize_t ret = write(conn->fd.fd, conn->u.write.buf, conn->u.write.len); + if (ret < 0) + return RESULT_CLOSE; + + conn->u.write.buf += ret; + conn->u.write.len -= ret; + if (conn->u.write.len == 0) + return RESULT_FINISHED; + else + return RESULT_AGAIN; +} + /* Queue some data to be written. */ struct io_plan *io_write_(struct io_conn *conn, const void *data, size_t len, struct io_plan *(*cb)(struct io_conn *, void *), @@ -123,9 +140,24 @@ struct io_plan *io_write_(struct io_conn *conn, const void *data, size_t len, { conn->u.write.buf = data; conn->u.write.len = len; - conn->fd.next = cb; - conn->fd.next_arg = arg; - return to_ioplan(WRITE); + conn->io = do_write; + conn->next = cb; + conn->next_arg = arg; + conn->pollflag = POLLOUT; + return to_ioplan(IO_IO); +} + +static enum io_result do_read(struct io_conn *conn) +{ + ssize_t ret = read(conn->fd.fd, conn->u.read.buf, conn->u.read.len); + if (ret <= 0) + return RESULT_CLOSE; + conn->u.read.buf += ret; + conn->u.read.len -= ret; + if (conn->u.read.len == 0) + return RESULT_FINISHED; + else + return RESULT_AGAIN; } /* Queue a request to read into a buffer. */ @@ -135,9 +167,21 @@ struct io_plan *io_read_(struct io_conn *conn, void *data, size_t len, { conn->u.read.buf = data; conn->u.read.len = len; - conn->fd.next = cb; - conn->fd.next_arg = arg; - return to_ioplan(READ); + conn->io = do_read; + conn->next = cb; + conn->next_arg = arg; + conn->pollflag = POLLIN; + return to_ioplan(IO_IO); +} + +static enum io_result do_read_partial(struct io_conn *conn) +{ + ssize_t ret = read(conn->fd.fd, conn->u.readpart.buf, + *conn->u.readpart.lenp); + if (ret <= 0) + return RESULT_CLOSE; + *conn->u.readpart.lenp = ret; + return RESULT_FINISHED; } /* Queue a partial request to read into a buffer. */ @@ -147,9 +191,21 @@ struct io_plan *io_read_partial_(struct io_conn *conn, void *data, size_t *len, { conn->u.readpart.buf = data; conn->u.readpart.lenp = len; - conn->fd.next = cb; - conn->fd.next_arg = arg; - return to_ioplan(READPART); + conn->io = do_read_partial; + conn->next = cb; + conn->next_arg = arg; + conn->pollflag = POLLIN; + return to_ioplan(IO_IO); +} + +static enum io_result do_write_partial(struct io_conn *conn) +{ + ssize_t ret = write(conn->fd.fd, conn->u.writepart.buf, + *conn->u.writepart.lenp); + if (ret < 0) + return RESULT_CLOSE; + *conn->u.writepart.lenp = ret; + return RESULT_FINISHED; } /* Queue a partial write request. */ @@ -160,14 +216,17 @@ struct io_plan *io_write_partial_(struct io_conn *conn, { conn->u.writepart.buf = data; conn->u.writepart.lenp = len; - conn->fd.next = cb; - conn->fd.next_arg = arg; - return to_ioplan(WRITEPART); + conn->io = do_write_partial; + conn->next = cb; + conn->next_arg = arg; + conn->pollflag = POLLOUT; + return to_ioplan(IO_IO); } struct io_plan *io_idle(struct io_conn *conn) { - return to_ioplan(IDLE); + conn->pollflag = 0; + return to_ioplan(IO_IDLE); } void io_wake_(struct io_conn *conn, @@ -175,74 +234,42 @@ void io_wake_(struct io_conn *conn, { /* It might have finished, but we haven't called its finish() yet. */ - if (conn->state == FINISHED) + if (conn->state == IO_FINISHED) return; - assert(conn->state == IDLE); - conn->fd.next = fn; - conn->fd.next_arg = arg; - backend_set_state(conn, to_ioplan(NEXT)); + assert(conn->state == IO_IDLE); + conn->next = fn; + conn->next_arg = arg; + conn->state = IO_NEXT; + backend_wakeup(conn); } static struct io_plan *do_next(struct io_conn *conn) { if (timeout_active(conn)) backend_del_timeout(conn); - return conn->fd.next(conn, conn->fd.next_arg); + return conn->next(conn, conn->next_arg); } struct io_plan *do_ready(struct io_conn *conn) { - ssize_t ret; - bool finished; - - switch (conn->state) { - case WRITE: - ret = write(conn->fd.fd, conn->u.write.buf, conn->u.write.len); - if (ret < 0) - return io_close(conn, NULL); - conn->u.write.buf += ret; - conn->u.write.len -= ret; - finished = (conn->u.write.len == 0); - break; - case WRITEPART: - ret = write(conn->fd.fd, conn->u.writepart.buf, - *conn->u.writepart.lenp); - if (ret < 0) - return io_close(conn, NULL); - *conn->u.writepart.lenp = ret; - finished = true; - break; - case READ: - ret = read(conn->fd.fd, conn->u.read.buf, conn->u.read.len); - if (ret <= 0) - return io_close(conn, NULL); - conn->u.read.buf += ret; - conn->u.read.len -= ret; - finished = (conn->u.read.len == 0); - break; - case READPART: - ret = read(conn->fd.fd, conn->u.readpart.buf, - *conn->u.readpart.lenp); - if (ret <= 0) - return io_close(conn, NULL); - *conn->u.readpart.lenp = ret; - finished = true; - break; + assert(conn->state == IO_IO); + switch (conn->io(conn)) { + case RESULT_CLOSE: + return io_close(conn, NULL); + case RESULT_FINISHED: + return do_next(conn); + case RESULT_AGAIN: + return to_ioplan(conn->state); default: - /* Shouldn't happen. */ abort(); } - - if (finished) - return do_next(conn); - return to_ioplan(conn->state); } /* Useful next functions. */ /* Close the connection, we're done. */ struct io_plan *io_close(struct io_conn *conn, void *arg) { - return to_ioplan(FINISHED); + return to_ioplan(IO_FINISHED); } /* Exit the loop, returning this (non-NULL) arg. */ @@ -251,8 +278,8 @@ struct io_plan *io_break_(struct io_conn *conn, void *ret, void *arg) { io_loop_return = ret; - conn->fd.next = fn; - conn->fd.next_arg = arg; + conn->next = fn; + conn->next_arg = arg; - return to_ioplan(NEXT); + return to_ioplan(IO_NEXT); }