//#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
};
struct tal_hdr {
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[];
};
+struct notifier {
+ struct prop_hdr hdr; /* NOTIFIER */
+ enum tal_notify_type types;
+ union {
+ void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+ void (*destroy)(tal_t *); /* If NOTIFY_IS_DESTRUCTOR set */
+ } u;
+};
+
static struct {
struct tal_hdr hdr;
struct children c;
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)
{
return (void *)((size_t)parent_child & ~(size_t)1);
}
-static bool initialized = false;
-
/* This means valgrind can see leaks. */
static void tal_cleanup(void)
{
t = (struct tal_hdr *)((char *)ctx - sizeof(struct tal_hdr));
check_bounds(t);
- if (t->prop && !is_literal(t->prop))
- check_bounds(t->prop);
check_bounds(ignore_destroying_bit(t->parent_child));
check_bounds(t->list.next);
check_bounds(t->list.prev);
+ if (t->prop && !is_literal(t->prop))
+ check_bounds(t->prop);
return t;
}
return to_tal_hdr(ctx);
}
-static void *from_tal_hdr(struct tal_hdr *hdr)
+static void *from_tal_hdr(const struct tal_hdr *hdr)
{
- return hdr + 1;
+ return (void *)(hdr + 1);
}
#ifdef TAL_DEBUG
}
#endif
+static void notify(const struct tal_hdr *ctx,
+ enum tal_notify_type type, const void *info)
+{
+ const struct prop_hdr *p;
+
+ for (p = ctx->prop; p; p = p->next) {
+ struct notifier *n;
+
+ if (is_literal(p))
+ break;
+ if (p->type != NOTIFIER)
+ continue;
+ n = (struct notifier *)p;
+ 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);
+ }
+ }
+}
+
static void *allocate(size_t size)
{
void *ret;
parent->prop = hdr;
}
-static struct destructor *add_destructor_property(struct tal_hdr *t,
- void (*destroy)(void *))
+static struct notifier *add_notifier_property(struct tal_hdr *t,
+ enum tal_notify_type types,
+ void (*fn)(void *,
+ enum tal_notify_type,
+ void *))
{
- struct destructor *prop = allocate(sizeof(*prop));
+ struct notifier *prop = allocate(sizeof(*prop));
if (prop) {
- init_property(&prop->hdr, t, DESTRUCTOR);
- prop->destroy = destroy;
+ init_property(&prop->hdr, t, NOTIFIER);
+ prop->types = types;
+ prop->u.notifyfn = fn;
}
return prop;
}
+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;
+
+ for (p = (struct prop_hdr **)&t->prop; *p; p = &(*p)->next) {
+ struct notifier *n;
+
+ if (is_literal(*p))
+ break;
+ if ((*p)->type != NOTIFIER)
+ continue;
+ n = (struct notifier *)*p;
+ if (n->u.notifyfn == fn) {
+ enum tal_notify_type types = n->types;
+ *p = (*p)->next;
+ freefn(n);
+ return types & ~NOTIFY_IS_DESTRUCTOR;
+ }
+ }
+ return 0;
+}
+
static struct name *add_name_property(struct tal_hdr *t, const char *name)
{
struct name *prop;
return true;
}
-static void del_tree(struct tal_hdr *t)
+static void del_tree(struct tal_hdr *t, const tal_t *orig)
{
struct prop_hdr **prop, *p, *next;
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);
/* Now free children and groups. */
prop = find_property_ptr(t, CHILDREN);
while ((i = list_top(&c->children, struct tal_hdr, list))) {
list_del(&i->list);
- del_tree(i);
+ del_tree(i, orig);
}
}
return NULL;
}
debug_tal(parent);
+ if (notifiers)
+ notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child));
return from_tal_hdr(debug_tal(child));
}
struct tal_hdr *t;
int saved_errno = errno;
t = debug_tal(to_tal_hdr(ctx));
+ if (notifiers)
+ notify(ignore_destroying_bit(t->parent_child)->parent,
+ TAL_NOTIFY_DEL_CHILD, ctx);
list_del(&t->list);
- del_tree(t);
+ del_tree(t, ctx);
errno = saved_errno;
}
return NULL;
return NULL;
}
debug_tal(newpar);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_STEAL, new_parent);
}
return (void *)ctx;
}
bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me))
{
- return add_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy);
+ tal_t *t = debug_tal(to_tal_hdr(ctx));
+ 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,
+ void (*callback)(tal_t *, enum tal_notify_type, void *))
+{
+ tal_t *t = debug_tal(to_tal_hdr(ctx));
+ struct notifier *n;
+
+ assert(types);
+ assert((types & ~(TAL_NOTIFY_FREE | TAL_NOTIFY_STEAL | TAL_NOTIFY_MOVE
+ | TAL_NOTIFY_RESIZE | TAL_NOTIFY_RENAME
+ | TAL_NOTIFY_ADD_CHILD | TAL_NOTIFY_DEL_CHILD
+ | TAL_NOTIFY_ADD_NOTIFIER
+ | TAL_NOTIFY_DEL_NOTIFIER)) == 0);
+
+ /* Don't call notifier about itself: set types after! */
+ n = add_notifier_property(t, 0, callback);
+ if (unlikely(!n))
+ return false;
+
+ 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,
+ void (*callback)(tal_t *, enum tal_notify_type, void *))
+{
+ struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
+ enum tal_notify_type types;
+
+ types = del_notifier_property(t, callback);
+ if (types) {
+ notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
+ if (types != TAL_NOTIFY_FREE)
+ notifiers--;
+ return true;
+ }
+ return false;
+}
+
+bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me))
+{
+ return tal_del_notifier_(ctx, (void *)destroy);
}
bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
/* Append literal. */
for (p = &t->prop; *p && !is_literal(*p); p = &(*p)->next);
*p = (struct prop_hdr *)name;
- return true;
- }
- if (!add_name_property(t, name))
+ } else if (!add_name_property(t, name))
return false;
+
debug_tal(t);
+ if (notifiers)
+ notify(t, TAL_NOTIFY_RENAME, name);
return true;
}
}
/* If it didn't move, we're done! */
- if (t == old_t)
- return true;
- update_bounds(t, size + sizeof(struct tal_hdr));
-
- /* Fix up linked list pointers. */
- if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
- t->list.next->prev = t->list.prev->next = &t->list;
-
- /* Fix up child property's parent pointer. */
- child = find_property(t, CHILDREN);
- if (child) {
- assert(child->parent == old_t);
- child->parent = t;
+ if (t != old_t) {
+ update_bounds(t, size + sizeof(struct tal_hdr));
+
+ /* Fix up linked list pointers. */
+ if (list_entry(t->list.next, struct tal_hdr, list) != old_t)
+ t->list.next->prev = t->list.prev->next = &t->list;
+
+ /* Fix up child property's parent pointer. */
+ child = find_property(t, CHILDREN);
+ if (child) {
+ assert(child->parent == old_t);
+ child->parent = t;
+ }
+ *ctxp = from_tal_hdr(debug_tal(t));
+ if (notifiers)
+ notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
}
- *ctxp = from_tal_hdr(debug_tal(t));
+ if (notifiers)
+ notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+
return true;
}
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)) {
printf(" \"%s\"", (const char *)p);
break;
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->u.notifyfn);
+ break;
default:
printf(" **UNKNOWN(%p):%i**", p, p->type);
}
"has two child nodes");
children = (struct children *)p;
break;
- case DESTRUCTOR:
+ case NOTIFIER:
break;
case NAME:
if (name)
projects / ccan / blobdiff