ccan/io: make union more generic.

[ccan] / ccan / io / io_plan.h

diff --git a/ccan/io/io_plan.h b/ccan/io/io_plan.h
index e87011e7d6a193e7591f2cdc44b400cb11b5ef0d..61d762454463b0f12868ff5a74fcdccbaa265f32 100644 (file)
--- a/ccan/io/io_plan.h
+++ b/ccan/io/io_plan.h
@@ -9,7 +9,8 @@ struct io_conn;
  * @io: function to call when fd is available for @pollflag.
  * @next: function to call after @io returns true.
  * @next_arg: argument to @next.
- * @u: scratch area for I/O.
+ * @u1: scratch area for I/O.
+ * @u2: scratch area for I/O.
  *
  * When the fd is POLLIN or POLLOUT (according to @pollflag), @io is
  * called.  If it returns -1, io_close() becomed the new plan (and errno
@@ -27,74 +28,105 @@ struct io_plan {
        void *next_arg;
 
        union {
-               struct {
-                       char *buf;
-                       size_t len;
-               } read;
-               struct {
-                       const char *buf;
-                       size_t len;
-               } write;
-               struct {
-                       char *buf;
-                       size_t *lenp;
-               } readpart;
-               struct {
-                       const char *buf;
-                       size_t *lenp;
-               } writepart;
-               struct {
-                       int saved_errno;
-               } close;
-               struct {
-                       void *p;
-                       size_t len;
-               } ptr_len;
-               struct {
-                       void *p1;
-                       void *p2;
-               } ptr_ptr;
-               struct {
-                       size_t len1;
-                       size_t len2;
-               } len_len;
-       } u;
+               char *cp;
+               void *vp;
+               const void *const_vp;
+               size_t s;
+               char c[sizeof(size_t)];
+       } u1;
+       union {
+               char *p;
+               void *vp;
+               const void *const_vp;
+               size_t s;
+               char c[sizeof(size_t)];
+       } u2;
 };
 
 #ifdef DEBUG
 /**
- * io_debug - routine to select connection(s) to debug.
+ * io_debug_conn - routine to select connection(s) to debug.
  *
  * If this is set, the routine should return true if the connection is a
  * debugging candidate.  If so, the callchain for I/O operations on this
  * connection will be linear, for easier use of a debugger.
+ *
+ * You will also see calls to any callbacks which wake the connection
+ * which is being debugged.
+ *
+ * Example:
+ *     static bool debug_all(struct io_conn *conn)
+ *     {
+ *             return true();
+ *     }
+ *     ...
+ *     io_debug_conn = debug_all;
  */
-extern bool (*io_debug)(struct io_conn *conn);
+extern bool (*io_debug_conn)(struct io_conn *conn);
 
 /**
- * io_plan_other - mark the next plan not being for the current connection
+ * io_debug - if we're debugging the current connection, call immediately.
  *
- * Most routines which take a plan are about to apply it to the current
- * connection.  We (ab)use this pattern for debugging: as soon as such a
- * plan is created, it is called, to create a linear call chain.
+ * This determines if we are debugging the current connection: if so,
+ * it immediately applies the plan and calls back into io_loop() to
+ * create a linear call chain.
  *
- * Some routines, like io_break() and io_wake() take an io_plan, but they
- * must not be applied immediately to the current connection, so we call this
- * first.
+ * Example:
+ *     #define io_idle() io_debug(io_idle_())
+ *     struct io_plan io_idle_(void);
  */
-#define io_plan_other() ((io_plan_for_other = true))
+struct io_plan io_debug(struct io_plan plan);
 
 /**
- * io_plan_debug - hook for debugging a plan.
+ * io_debug_io - return from function which actually does I/O.
  *
- * After constructing a plan, call this.  If the current connection is being
- * debugged, then it will be immediately serviced with this plan.
+ * This determines if we are debugging the current connection: if so,
+ * it immediately sets the next function and calls into io_loop() to
+ * create a linear call chain.
+ *
+ * Example:
+ *
+ * static int do_write(int fd, struct io_plan *plan)
+ * {
+ *     ssize_t ret = write(fd, plan->u.write.buf, plan->u.write.len);
+ *     if (ret < 0)
+ *             return io_debug_io(-1);
+ *
+ *     plan->u.write.buf += ret;
+ *     plan->u.write.len -= ret;
+ *     return io_debug_io(plan->u.write.len == 0);
+ * }
  */
-void io_plan_debug(struct io_plan *plan);
-extern bool io_plan_for_other;
+int io_debug_io(int ret);
+
+/**
+ * io_plan_no_debug - mark the next plan not to be called immediately.
+ *
+ * Most routines which take a plan are about to apply it to the current
+ * connection.  We (ab)use this pattern for debugging: as soon as such a
+ * plan is created it is called, to create a linear call chain.
+ *
+ * Some routines, like io_break(), io_duplex() and io_wake() take an
+ * io_plan, but they must not be applied immediately to the current
+ * connection, so we call this first.
+ *
+ * Example:
+ * #define io_break(ret, plan) (io_plan_no_debug(), io_break_((ret), (plan)))
+ * struct io_plan io_break_(void *ret, struct io_plan plan);
+ */
+#define io_plan_no_debug() ((io_plan_nodebug = true))
+
+extern bool io_plan_nodebug;
 #else
-#define io_plan_other() (void)0
-static inline void io_plan_debug(struct io_plan *plan) { }
+static inline struct io_plan io_debug(struct io_plan plan)
+{
+       return plan;
+}
+static inline int io_debug_io(int ret)
+{
+       return ret;
+}
+#define io_plan_no_debug() (void)0
 #endif
 
 #endif /* CCAN_IO_PLAN_H */