X-Git-Url: http://git.ozlabs.org/?a=blobdiff_plain;f=ccan%2Ftal%2Ftal.c;h=866f263ba871f7e2ca4cb430bc9a790f1637b941;hb=96dcdfbf1a400f7cb43cf3f0761f52fd6de9ff65;hp=df4020ea07e4997b6888d9418cf521fa74437e6a;hpb=77aa87f08799dafb2f4db6e967f0a3996e5ba883;p=ccan

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index df4020ea..866f263b 100644
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -47,7 +47,7 @@ struct name {
 
 struct length {
 	struct prop_hdr hdr; /* LENGTH */
-	size_t count;
+	size_t len;
 };
 
 struct notifier {
@@ -203,7 +203,8 @@ static struct tal_hdr *debug_tal(struct tal_hdr *tal)
 #endif
 
 static void notify(const struct tal_hdr *ctx,
-		   enum tal_notify_type type, const void *info)
+		   enum tal_notify_type type, const void *info,
+		   int saved_errno)
 {
         const struct prop_hdr *p;
 
@@ -216,6 +217,7 @@ static void notify(const struct tal_hdr *ctx,
 			continue;
 		n = (struct notifier *)p;
 		if (n->types & type) {
+			errno = saved_errno;
 			if (n->types & NOTIFY_IS_DESTRUCTOR)
 				n->u.destroy(from_tal_hdr(ctx));
 			else
@@ -323,7 +325,7 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name)
 }
 
 static struct children *add_child_property(struct tal_hdr *parent,
-					   struct tal_hdr *child)
+					   struct tal_hdr *child UNNEEDED)
 {
 	struct children *prop = allocate(sizeof(*prop));
 	if (prop) {
@@ -348,7 +350,7 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
 	return true;
 }
 
-static void del_tree(struct tal_hdr *t, const tal_t *orig)
+static void del_tree(struct tal_hdr *t, const tal_t *orig, int saved_errno)
 {
 	struct prop_hdr **prop, *p, *next;
 
@@ -359,7 +361,7 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
         set_destroying_bit(&t->parent_child);
 
 	/* Call free notifiers. */
-	notify(t, TAL_NOTIFY_FREE, (tal_t *)orig);
+	notify(t, TAL_NOTIFY_FREE, (tal_t *)orig, saved_errno);
 
 	/* Now free children and groups. */
 	prop = find_property_ptr(t, CHILDREN);
@@ -369,7 +371,7 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
 
 		while ((i = list_top(&c->children, struct tal_hdr, list))) {
 			list_del(&i->list);
-			del_tree(i, orig);
+			del_tree(i, orig, saved_errno);
 		}
 	}
 
@@ -383,23 +385,50 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
         freefn(t);
 }
 
-void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
+static size_t extra_for_length(size_t size)
 {
+	size_t extra;
+	const size_t align = ALIGNOF(struct length);
+
+	/* Round up size, and add tailer. */
+	extra = ((size + align-1) & ~(align-1)) - size;
+	extra += sizeof(struct length);
+	return extra;
+}
+
+void *tal_alloc_(const tal_t *ctx, size_t size,
+		 bool clear, bool add_length, const char *label)
+{
+	size_t req_size = size;
         struct tal_hdr *child, *parent = debug_tal(to_tal_hdr_or_null(ctx));
 
+#ifdef CCAN_TAL_DEBUG
+	/* Always record length if debugging. */
+	add_length = true;
+#endif
+	if (add_length)
+		size += extra_for_length(size);
+
         child = allocate(sizeof(struct tal_hdr) + size);
 	if (!child)
 		return NULL;
 	if (clear)
-		memset(from_tal_hdr(child), 0, size);
+		memset(from_tal_hdr(child), 0, req_size);
         child->prop = (void *)label;
+
+	if (add_length) {
+		struct length *lprop;
+		lprop = (struct length *)((char *)(child+1) + size) - 1;
+		init_property(&lprop->hdr, child, LENGTH);
+		lprop->len = req_size;
+	}
         if (!add_child(parent, child)) {
 		freefn(child);
 		return NULL;
 	}
 	debug_tal(parent);
 	if (notifiers)
-		notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child));
+		notify(parent, TAL_NOTIFY_ADD_CHILD, from_tal_hdr(child), 0);
 	return from_tal_hdr(debug_tal(child));
 }
 
@@ -422,39 +451,13 @@ overflow:
 	return false;
 }
 
-static size_t extra_for_length(size_t size)
-{
-	size_t extra;
-	const size_t align = ALIGNOF(struct length);
-
-	/* Round up size, and add tailer. */
-	extra = ((size + align-1) & ~(align-1)) - size;
-	extra += sizeof(struct length);
-	return extra;
-}
-
 void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
-		     bool add_count, const char *label)
+		     bool add_length, const char *label)
 {
-	void *ret;
-
 	if (!adjust_size(&size, count))
 		return NULL;
 
-	if (add_count)
-		size += extra_for_length(size);
-
-	ret = tal_alloc_(ctx, size, clear, label);
-	if (unlikely(!ret))
-		return ret;
-
-	if (add_count) {
-		struct length *lprop;
-		lprop = (struct length *)((char *)ret + size) - 1;
-		init_property(&lprop->hdr, to_tal_hdr(ret), LENGTH);
-		lprop->count = count;
-	}
-	return ret;
+	return tal_alloc_(ctx, size, clear, add_length, label);
 }
 
 void *tal_free(const tal_t *ctx)
@@ -465,9 +468,9 @@ void *tal_free(const tal_t *ctx)
 		t = debug_tal(to_tal_hdr(ctx));
 		if (notifiers)
 			notify(ignore_destroying_bit(t->parent_child)->parent,
-			       TAL_NOTIFY_DEL_CHILD, ctx);
+			       TAL_NOTIFY_DEL_CHILD, ctx, saved_errno);
 		list_del(&t->list);
-		del_tree(t, ctx);
+		del_tree(t, ctx, saved_errno);
 		errno = saved_errno;
 	}
 	return NULL;
@@ -494,7 +497,7 @@ void *tal_steal_(const tal_t *new_parent, const tal_t *ctx)
 		}
 		debug_tal(newpar);
 		if (notifiers)
-			notify(t, TAL_NOTIFY_STEAL, new_parent);
+			notify(t, TAL_NOTIFY_STEAL, new_parent, 0);
         }
         return (void *)ctx;
 }
@@ -525,7 +528,7 @@ bool tal_add_notifier_(const tal_t *ctx, enum tal_notify_type types,
 		return false;
 
 	if (notifiers)
-		notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback);
+		notify(t, TAL_NOTIFY_ADD_NOTIFIER, callback, 0);
 
 	n->types = types;
 	if (types != TAL_NOTIFY_FREE)
@@ -541,7 +544,7 @@ bool tal_del_notifier_(const tal_t *ctx,
 
         types = del_notifier_property(t, callback);
 	if (types) {
-		notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback);
+		notify(t, TAL_NOTIFY_DEL_NOTIFIER, callback, 0);
 		if (types != TAL_NOTIFY_FREE)
 			notifiers--;
 		return true;
@@ -581,7 +584,7 @@ bool tal_set_name_(tal_t *ctx, const char *name, bool literal)
 
 	debug_tal(t);
 	if (notifiers)
-		notify(t, TAL_NOTIFY_RENAME, name);
+		notify(t, TAL_NOTIFY_RENAME, name, 0);
 	return true;
 }
 
@@ -598,14 +601,14 @@ const char *tal_name(const tal_t *t)
 	return n->name;
 }
 
-size_t tal_count(const tal_t *ptr)
+size_t tal_len(const tal_t *ptr)
 {
 	struct length *l;
 
 	l = find_property(debug_tal(to_tal_hdr(ptr)), LENGTH);
 	if (!l)
 		return 0;
-	return l->count;
+	return l->len;
 }
 
 /* Start one past first child: make stopping natural in circ. list. */
@@ -661,7 +664,7 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
         struct children *child;
 	struct prop_hdr **lenp;
 	struct length len;
-	size_t extra = 0, elemsize = size;
+	size_t extra = 0;
 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
@@ -687,13 +690,14 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
 		struct length *new_len;
 
 		/* Clear between old end and new end. */
-		if (clear && count > len.count) {
-			char *old_end = (char *)(t + 1) + len.count * elemsize;
-			memset(old_end, 0, elemsize * (count - len.count));
+		if (clear && size > len.len) {
+			char *old_end = (char *)(t + 1) + len.len;
+			memset(old_end, 0, size - len.len);
 		}
 
-		new_len = (struct length *)((char *)(t + 1) + size);
-		len.count = count;
+		new_len = (struct length *)((char *)(t + 1) + size
+					    + extra - sizeof(len));
+		len.len = size;
 		*new_len = len;
 
 		/* Be careful replacing next ptr; could be old hdr. */
@@ -718,10 +722,10 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
 		}
 		*ctxp = from_tal_hdr(debug_tal(t));
 		if (notifiers)
-			notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
+			notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t), 0);
 	}
 	if (notifiers)
-		notify(t, TAL_NOTIFY_RESIZE, (void *)size);
+		notify(t, TAL_NOTIFY_RESIZE, (void *)size, 0);
 
 	return true;
 }
@@ -729,26 +733,26 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)
 bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)
 {
 	struct length *l;
-	size_t old_count;
+	size_t old_len;
 	bool ret = false;
 
 	l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
-	old_count = l->count;
+	old_len = l->len;
 
 	/* Check for additive overflow */
-	if (old_count + count < count) {
+	if (old_len + count * size < old_len) {
 		call_error("dup size overflow");
 		goto out;
 	}
 
 	/* Don't point src inside thing we're expanding! */
 	assert(src < *ctxp
-	       || (char *)src >= (char *)(*ctxp) + (size * old_count));
+	       || (char *)src >= (char *)(*ctxp) + old_len);
 
-	if (!tal_resize_(ctxp, size, old_count + count, false))
+	if (!tal_resize_(ctxp, size, old_len/size + count, false))
 		goto out;
 
-	memcpy((char *)*ctxp + size * old_count, src, count * size);
+	memcpy((char *)*ctxp + old_len, src, count * size);
 	ret = true;
 
 out:
@@ -758,7 +762,7 @@ out:
 }
 
 void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
-	       size_t n, size_t extra, bool add_count,
+	       size_t n, size_t extra, bool add_length,
 	       const char *label)
 {
 	void *ret;
@@ -788,7 +792,7 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
 		return (void *)p;
 	}
 
-	ret = tal_alloc_arr_(ctx, size, n + extra, false, add_count, label);
+	ret = tal_alloc_arr_(ctx, size, n + extra, false, add_length, label);
 	if (ret)
 		memcpy(ret, p, nbytes);
 	return ret;
@@ -844,7 +848,7 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
 			break;
 		case LENGTH:
 			l = (struct length *)p;
-			printf(" LENGTH(%p):count=%zu", p, l->count);
+			printf(" LENGTH(%p):len=%zu", p, l->len);
 			break;
 		default:
 			printf(" **UNKNOWN(%p):%i**", p, p->type);