CHILDREN = 0x00c1d500,
DESTRUCTOR = 0x00de5700,
NAME = 0x00111100,
+ NOTIFIER = 0x00071f00
};
struct tal_hdr {
char name[];
};
+struct notifier {
+ struct prop_hdr hdr; /* NOTIFIER */
+ enum tal_notify_type types;
+ void (*notifyfn)(tal_t *, enum tal_notify_type, void *);
+};
+
static struct {
struct tal_hdr hdr;
struct children c;
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)
+ n->notifyfn(from_tal_hdr(ctx), type, (void *)info);
+ }
+}
+
static void *allocate(size_t size)
{
void *ret;
return false;
}
+static struct notifier *add_notifier_property(struct tal_hdr *t,
+ enum tal_notify_type types,
+ void (*fn)(void *,
+ enum tal_notify_type,
+ void *))
+{
+ struct notifier *prop = allocate(sizeof(*prop));
+ if (prop) {
+ init_property(&prop->hdr, t, NOTIFIER);
+ prop->types = types;
+ prop->notifyfn = fn;
+ }
+ return prop;
+}
+
+static bool 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->notifyfn == fn) {
+ *p = (*p)->next;
+ freefn(n);
+ return true;
+ }
+ }
+ return false;
+}
+
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;
freefn(d);
}
+ /* Call free notifiers. */
+ notify(t, TAL_NOTIFY_FREE, (tal_t *)orig);
+
/* Now free children and groups. */
prop = find_property_ptr(t, CHILDREN);
if (prop) {
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);
+ notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(debug_tal(child)));
return from_tal_hdr(debug_tal(child));
}
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);
list_del(&t->list);
- del_tree(t);
+ del_tree(t, ctx);
errno = saved_errno;
}
return NULL;
return NULL;
}
debug_tal(newpar);
+ 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_destructor_property(t, 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;
+
+ notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+ n->types = types;
+ 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));
+ bool ret;
+
+ ret = del_notifier_property(t, callback);
+ if (ret)
+ notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
+ return ret;
}
bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me))
{
- return del_destructor_property(debug_tal(to_tal_hdr(ctx)), destroy);
+ struct tal_hdr *t = debug_tal(to_tal_hdr(ctx));
+ return del_destructor_property(t, 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);
+ 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));
+ notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
}
- *ctxp = from_tal_hdr(debug_tal(t));
+ notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+
return true;
}
struct children *c;
struct destructor *d;
struct name *n;
+ struct notifier *no;
if (is_literal(p)) {
printf(" \"%s\"", (const char *)p);
break;
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);
+ break;
default:
printf(" **UNKNOWN(%p):%i**", p, p->type);
}
children = (struct children *)p;
break;
case DESTRUCTOR:
+ case NOTIFIER:
break;
case NAME:
if (name)
* tal_add_destructor - add a callback function when this context is destroyed.
* @ptr: The tal allocated object.
* @function: the function to call before it's freed.
+ *
+ * Note that this can only fail if your allocfn fails and your errorfn returns.
*/
#define tal_add_destructor(ptr, function) \
tal_add_destructor_((ptr), typesafe_cb(void, void *, (function), (ptr)))
#define tal_del_destructor(ptr, function) \
tal_del_destructor_((ptr), typesafe_cb(void, void *, (function), (ptr)))
+enum tal_notify_type {
+ TAL_NOTIFY_FREE = 1,
+ TAL_NOTIFY_STEAL = 2,
+ TAL_NOTIFY_MOVE = 4,
+ TAL_NOTIFY_RESIZE = 8,
+ TAL_NOTIFY_RENAME = 16,
+ TAL_NOTIFY_ADD_CHILD = 32,
+ TAL_NOTIFY_DEL_CHILD = 64,
+ TAL_NOTIFY_ADD_NOTIFIER = 128,
+ TAL_NOTIFY_DEL_NOTIFIER = 256
+};
+
+/**
+ * tal_add_notifier - add a callback function when this context changes.
+ * @ptr: The tal allocated object.
+ * @types: Bitwise OR of the types the callback is interested in.
+ * @callback: the function to call.
+ *
+ * Note that this can only fail if your allocfn fails and your errorfn
+ * returns. Also note that notifiers are not reliable in the case
+ * where an allocation fails, as they may be called before any
+ * allocation is actually done.
+ *
+ * TAL_NOTIFY_FREE is called when @ptr is freed, either directly or
+ * because an ancestor is freed: @info is the argument to tal_free().
+ * It is exactly equivalent to a destructor, with more information.
+ *
+ * TAL_NOTIFY_STEAL is called when @ptr's parent changes: @info is the
+ * new parent.
+ *
+ * TAL_NOTIFY_MOVE is called when @ptr is realloced (via tal_resize)
+ * and moved. In this case, @ptr arg here is the new memory, and
+ * @info is the old pointer.
+ *
+ * TAL_NOTIFY_RESIZE is called when @ptr is realloced via tal_resize:
+ * @info is the new size, in bytes. If the pointer has moved,
+ * TAL_NOTIFY_MOVE callbacks are called first.
+ *
+ * TAL_NOTIFY_ADD_CHILD/TAL_NOTIFY_DEL_CHILD are called when @ptr is
+ * the context for a tal() allocating call, or a direct child is
+ * tal_free()d: @info is the child. Note that TAL_NOTIFY_DEL_CHILD is
+ * not called when this context is tal_free()d: TAL_NOTIFY_FREE is
+ * considered sufficient for that case.
+ *
+ * TAL_NOTIFY_ADD_NOTIFIER/TAL_NOTIFIER_DEL_NOTIFIER are called when
+ * a notifier is added or removed (not for this notifier): @info is the
+ * callback.
+ */
+#define tal_add_notifier(ptr, types, callback) \
+ tal_add_notifier_((ptr), (types), \
+ typesafe_cb_postargs(void, tal_t *, (callback), \
+ (ptr), \
+ enum tal_notify_type, void *))
+
+/**
+ * tal_del_notifier - remove a notifier callback function.
+ * @ptr: The tal allocated object.
+ * @callback: the function to call.
+ */
+#define tal_del_notifier(ptr, callback) \
+ tal_del_notifier_((ptr), \
+ typesafe_cb_postargs(void, void *, (callback), \
+ (ptr), \
+ enum tal_notify_type, void *))
+
/**
* tal_set_name - attach a name to a tal pointer.
* @ptr: The tal allocated object.
bool tal_add_destructor_(tal_t *ctx, void (*destroy)(void *me));
bool tal_del_destructor_(tal_t *ctx, void (*destroy)(void *me));
+bool tal_add_notifier_(tal_t *ctx, enum tal_notify_type types,
+ void (*notify)(tal_t *ctx, enum tal_notify_type,
+ void *info));
+bool tal_del_notifier_(tal_t *ctx,
+ void (*notify)(tal_t *ctx, enum tal_notify_type,
+ void *info));
#endif /* CCAN_TAL_H */
--- /dev/null
+#include <ccan/tal/tal.h>
+#include <ccan/tal/tal.c>
+#include <ccan/tap/tap.h>
+
+static enum tal_notify_type expect;
+static void *expect_info;
+static char *ctx;
+static unsigned int notified1, notified2;
+
+/* Make sure we always move on resize. */
+static void *my_realloc(void *old, size_t size)
+{
+ void *new = realloc(old, size);
+ if (new == old) {
+ void *p = malloc(size);
+ memcpy(p, old, size);
+ free(old);
+ new = p;
+ }
+ return new;
+}
+
+static void notify1(char *p, enum tal_notify_type notify, void *info)
+{
+ ok1(ctx == ctx);
+ ok1(notify == expect);
+ if (expect_info == &expect_info)
+ expect_info = info;
+ else
+ ok1(info == expect_info);
+ notified1++;
+}
+
+static void notify2(char *ctx, enum tal_notify_type notify, void *info)
+{
+ notified2++;
+}
+
+static bool seen_move, seen_resize;
+static void resize_notifier(char *p, enum tal_notify_type notify, void *info)
+{
+ if (notify == TAL_NOTIFY_MOVE) {
+ ok1(!seen_move);
+ ok1(!seen_resize);
+ ok1(info == ctx);
+ ok1(p != ctx);
+ ctx = p;
+ seen_move = true;
+ } else if (notify == TAL_NOTIFY_RESIZE) {
+ ok1(!seen_resize);
+ ok1(seen_move);
+ ok1(p == ctx);
+ ok1((size_t)info == 100);
+ seen_resize = true;
+ } else
+ fail("Unexpected notifier %i", notify);
+}
+
+int main(void)
+{
+ char *child, *new_ctx;
+
+ plan_tests(56);
+
+ ctx = tal(NULL, char);
+ ok1(tal_add_notifier(ctx, 511, notify1));
+ ok1(notified1 == 0);
+ ok1(notified2 == 0);
+
+ expect = TAL_NOTIFY_STEAL;
+ expect_info = NULL;
+ ok1(tal_steal(NULL, ctx) == ctx);
+ ok1(notified1 == 1);
+
+ expect = TAL_NOTIFY_ADD_NOTIFIER;
+ expect_info = notify2;
+ ok1(tal_add_notifier(ctx, TAL_NOTIFY_RENAME|TAL_NOTIFY_ADD_NOTIFIER
+ |TAL_NOTIFY_DEL_NOTIFIER, notify2));
+ ok1(notified1 == 2);
+ ok1(notified2 == 0);
+
+ expect = TAL_NOTIFY_RENAME;
+ expect_info = (char *)"newname";
+ ok1(tal_set_name(ctx, (char *)expect_info));
+ ok1(notified1 == 3);
+ ok1(notified2 == 1);
+
+ expect = TAL_NOTIFY_DEL_NOTIFIER;
+ expect_info = notify2;
+ ok1(tal_del_notifier(ctx, notify2));
+ ok1(notified1 == 4);
+ ok1(notified2 == 1);
+
+ /* Failed delete should not call notifier! */
+ expect = TAL_NOTIFY_DEL_NOTIFIER;
+ expect_info = notify2;
+ ok1(!tal_del_notifier(ctx, notify2));
+ ok1(notified1 == 4);
+ ok1(notified2 == 1);
+
+ expect = TAL_NOTIFY_ADD_CHILD;
+ expect_info = &expect_info;
+ child = tal(ctx, char);
+ ok1(notified1 == 5);
+ ok1(notified2 == 1);
+ ok1(expect_info == child);
+
+ expect = TAL_NOTIFY_DEL_CHILD;
+ expect_info = child;
+ tal_free(child);
+ ok1(notified1 == 6);
+ ok1(notified2 == 1);
+
+ expect = TAL_NOTIFY_FREE;
+ expect_info = ctx;
+ tal_free(ctx);
+ ok1(notified1 == 7);
+ ok1(notified2 == 1);
+
+ tal_set_backend(NULL, my_realloc, NULL, NULL);
+ ctx = new_ctx = tal(NULL, char);
+ ok1(tal_add_notifier(new_ctx, 511, resize_notifier));
+ ok1(tal_resize(&new_ctx, 100));
+ ok1(seen_move);
+ ok1(seen_resize);
+ tal_del_notifier(new_ctx, resize_notifier);
+ tal_free(new_ctx);
+
+ return exit_status();
+}
projects / ccan / commitdiff