tal: adding or removing a notifier/destructor can be const.

[ccan] / ccan / tal / tal.c

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index 9b84c6e17bdf9b94856157d54bbab4f648981406..d8a15f45c2a8ff04f43f21a4776c9eb135e693df 100644 (file)
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -13,10 +13,11 @@
 
 //#define TAL_DEBUG 1
 
+#define NOTIFY_IS_DESTRUCTOR 512
+
 /* 32-bit type field, first byte 0 in either endianness. */
 enum prop_type {
        CHILDREN = 0x00c1d500,
-       DESTRUCTOR = 0x00de5700,
        NAME = 0x00111100,
        NOTIFIER = 0x00071f00
 };
@@ -38,11 +39,6 @@ struct children {
        struct list_head children; /* Head of siblings. */
 };
 
-struct destructor {
-       struct prop_hdr hdr; /* DESTRUCTOR */
-       void (*destroy)(void *me);
-};
-
 struct name {
        struct prop_hdr hdr; /* NAME */
        char name[];
@@ -51,7 +47,10 @@ struct name {
 struct notifier {
        struct prop_hdr hdr; /* NOTIFIER */
        enum tal_notify_type types;
-       void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+       union {
+               void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+               void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */
+       } u;
 };
 
 static struct {
@@ -71,6 +70,9 @@ static void *(*allocfn)(size_t size) = malloc;
 static void *(*resizefn)(void *, size_t size) = realloc;
 static void (*freefn)(void *) = free;
 static void (*errorfn)(const char *msg) = (void *)abort;
+static bool initialized = false;
+/* Count on non-destrutor notifiers; often stays zero. */
+static size_t notifiers = 0;
 
 static inline void COLD call_error(const char *msg)
 {
@@ -92,8 +94,6 @@ static struct children *ignore_destroying_bit(struct children *parent_child)
        return (void *)((size_t)parent_child & ~(size_t)1);
 }
 
-static bool initialized = false;
-
 /* This means valgrind can see leaks. */
 static void tal_cleanup(void)
 {
@@ -214,8 +214,13 @@ static void notify(const struct tal_hdr *ctx,
                 if (p->type != NOTIFIER)
                        continue;
                n = (struct notifier *)p;
-               if (n->types & type)
-                       n->notifyfn(from_tal_hdr(ctx), type, (void *)info);
+               if (n->types & type) {
+                       if (n->types & NOTIFY_IS_DESTRUCTOR)
+                               n->u.destroy(from_tal_hdr(ctx));
+                       else
+                               n->u.notifyfn(from_tal_hdr(ctx), type,
+                                             (void *)info);
+               }
        }
 }
 
@@ -272,39 +277,6 @@ static void init_property(struct prop_hdr *hdr,
        parent->prop = hdr;
 }
 
-static struct destructor *add_destructor_property(struct tal_hdr *t,
-                                                 void (*destroy)(void *))
-{
-       struct destructor *prop = allocate(sizeof(*prop));
-       if (prop) {
-               init_property(&prop->hdr, t, DESTRUCTOR);
-               prop->destroy = destroy;
-       }
-       return prop;
-}
-
-static bool del_destructor_property(struct tal_hdr *t,
-                                   void (*destroy)(void *))
-{
-        struct prop_hdr **p;
-
-        for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
-               struct destructor *d;
-
-                if (is_literal(*p))
-                       break;
-                if ((*p)->type != DESTRUCTOR)
-                       continue;
-               d = (struct destructor *)*p;
-               if (d->destroy == destroy) {
-                       *p = (*p)->next;
-                       freefn(d);
-                       return true;
-               }
-        }
-        return false;
-}
-
 static struct notifier *add_notifier_property(struct tal_hdr *t,
                                              enum tal_notify_type types,
                                              void (*fn)(void *,
@@ -315,14 +287,15 @@ static struct notifier *add_notifier_property(struct tal_hdr *t,
        if (prop) {
                init_property(&prop->hdr, t, NOTIFIER);
                prop->types = types;
-               prop->notifyfn = fn;
+               prop->u.notifyfn = fn;
        }
        return prop;
 }
 
-static bool del_notifier_property(struct tal_hdr *t,
-                                 void (*fn)(tal_t *,
-                                            enum tal_notify_type, void *))
+static enum tal_notify_type del_notifier_property(struct tal_hdr *t,
+                                                 void (*fn)(tal_t *,
+                                                            enum tal_notify_type,
+                                                            void *))
 {
         struct prop_hdr **p;
 
@@ -334,13 +307,14 @@ static bool del_notifier_property(struct tal_hdr *t,
                 if ((*p)->type != NOTIFIER)
                        continue;
                n = (struct notifier *)*p;
-               if (n->notifyfn == fn) {
+               if (n->u.notifyfn == fn) {
+                       enum tal_notify_type types = n->types;
                        *p = (*p)->next;
                        freefn(n);
-                       return true;
+                       return types & ~NOTIFY_IS_DESTRUCTOR;
                }
         }
-        return false;
+        return 0;
 }
 
 static struct name *add_name_property(struct tal_hdr *t, const char *name)
@@ -396,14 +370,6 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
 
         set_destroying_bit(&t->parent_child);
 
-        /* Carefully call destructors, removing as we go. */
-        while ((prop = find_property_ptr(t, DESTRUCTOR))) {
-               struct destructor *d = (struct destructor *)*prop;
-                d->destroy(from_tal_hdr(t));
-                *prop = d->hdr.next;
-               freefn(d);
-        }
-
        /* Call free notifiers. */
        notify(t, TAL_NOTIFY_FREE, (tal_t *)orig);
 
@@ -442,7 +408,8 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
                return NULL;
        }
        debug_tal(parent);
-       notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(debug_tal(child)));
+       if (notifiers)
+               notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child));
        return from_tal_hdr(debug_tal(child));
 }
 
@@ -452,8 +419,9 @@ void *tal_free(const tal_t *ctx)
                struct tal_hdr *t;
                int saved_errno = errno;
                t = debug_tal(to_tal_hdr(ctx));
-               notify(ignore_destroying_bit(t->parent_child)->parent,
-                      TAL_NOTIFY_DEL_CHILD, ctx);
+               if (notifiers)
+                       notify(ignore_destroying_bit(t->parent_child)->parent,
+                              TAL_NOTIFY_DEL_CHILD, ctx);
                list_del(&t->list);
                del_tree(t, ctx);
                errno = saved_errno;
@@ -481,18 +449,20 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx)
                        return NULL;
                }
                debug_tal(newpar);
-               notify(t, TAL_NOTIFY_STEAL, new_parent);
+               if (notifiers)
+                       notify(t, TAL_NOTIFY_STEAL, new_parent);
         }
         return (void *)ctx;
 }
 
-bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_add_destructor_(const tal_t *ctx, void (*destroy)(void *me))
 {
        tal_t *t = debug_tal(to_tal_hdr(ctx));
-        return add_destructor_property(t, destroy);
+       return add_notifier_property(t, TAL_NOTIFY_FREE|NOTIFY_IS_DESTRUCTOR,
+                                    (void *)destroy);
 }
 
-bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
+bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types,
                       void (*callback)(tal_t *, enum tal_notify_type, void *))
 {
        tal_t *t = debug_tal(to_tal_hdr(ctx));
@@ -510,27 +480,34 @@ bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
        if (unlikely(!n))
                return false;
 
-       notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+       if (notifiers)
+               notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+
        n->types = types;
+       if (types != TAL_NOTIFY_FREE)
+               notifiers++;
        return true;
 }
 
-bool tal_del_notifier_(tal_t *ctx,
+bool tal_del_notifier_(const tal_t *ctx,
                       void (*callback)(tal_t *, enum tal_notify_type, void *))
 {
        struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
-       bool ret;
+       enum tal_notify_type types;
 
-        ret = del_notifier_property(t, callback);
-       if (ret)
+        types = del_notifier_property(t, callback);
+       if (types) {
                notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
-       return ret;
+               if (types != TAL_NOTIFY_FREE)
+                       notifiers--;
+               return true;
+       }
+       return false;
 }
 
-bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me))
+bool tal_del_destructor_(const tal_t *ctx, void (*destroy)(void *me))
 {
-       struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
-        return del_destructor_property(t, destroy);
+       return tal_del_notifier_(ctx, (void *)destroy);
 }
 
 bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
@@ -559,7 +536,8 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
                return false;
 
        debug_tal(t);
-       notify(t, TAL_NOTIFY_RENAME, name);
+       if (notifiers)
+               notify(t, TAL_NOTIFY_RENAME, name);
        return true;
 }
 
@@ -672,9 +650,11 @@ bool tal_resize_(tal_t **ctxp, size_t size)
                        child->parent = t;
                }
                *ctxp = from_tal_hdr(debug_tal(t));
-               notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
+               if (notifiers)
+                       notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
        }
-       notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+       if (notifiers)
+               notify(t, TAL_NOTIFY_RESIZE, (void *)size);
 
        return true;
 }
@@ -799,7 +779,6 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
        printf("%p", t);
         for (p = t->prop; p; p = p->next) {
                struct children *c;
-               struct destructor *d;
                struct name *n;
                struct notifier *no;
                 if (is_literal(p)) {
@@ -813,17 +792,13 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
                               p, c->parent,
                               c->children.n.prev, c->children.n.next);
                        break;
-               case DESTRUCTOR:
-                       d = (struct destructor *)p;
-                       printf(" DESTRUCTOR(%p):fn=%p", p, d->destroy);
-                       break;
                case NAME:
                        n = (struct name *)p;
                        printf(" NAME(%p):%s", p, n->name);
                        break;
                case NOTIFIER:
                        no = (struct notifier *)p;
-                       printf(" NOTIFIER(%p):fn=%p", p, no->notifyfn);
+                       printf(" NOTIFIER(%p):fn=%p", p, no->u.notifyfn);
                        break;
                default:
                        printf(" **UNKNOWN(%p):%i**", p, p->type);
@@ -898,7 +873,6 @@ static bool check_node(struct children *parent_child,
                                                 "has two child nodes");
                        children = (struct children *)p;
                        break;
-               case DESTRUCTOR:
                case NOTIFIER:
                        break;
                case NAME: