tal: store length in bytes, not count, and always store if CCAN_TAL_DEBUG.

[ccan] / ccan / tal / tal.c

diff --git a/ccan/tal/tal.c b/ccan/tal/tal.c
index c78185be01aa12715a0499088974ab8f561ccee6..79476772c585564b7e0840f215b59d09844723f1 100644 (file)
--- a/ccan/tal/tal.c
+++ b/ccan/tal/tal.c
@@ -3,9 +3,9 @@
 #include <ccan/compiler/compiler.h>
 #include <ccan/list/list.h>
 #include <ccan/take/take.h>
 #include <ccan/compiler/compiler.h>
 #include <ccan/list/list.h>
 #include <ccan/take/take.h>

+#include <ccan/alignof/alignof.h>

 #include <assert.h>
 #include <stdio.h>
 #include <assert.h>
 #include <stdio.h>

-#include <stdarg.h>

 #include <stddef.h>
 #include <string.h>
 #include <limits.h>
 #include <stddef.h>
 #include <string.h>
 #include <limits.h>


@@ -47,7 +47,7 @@ struct name {
 
 struct length {
        struct prop_hdr hdr; /* LENGTH */
 
 struct length {
        struct prop_hdr hdr; /* LENGTH */

-       size_t count;
+       size_t len;

 };
 
 struct notifier {
 };
 
 struct notifier {


@@ -76,7 +76,6 @@ 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 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;
 
 /* Count on non-destrutor notifiers; often stays zero. */
 static size_t notifiers = 0;
 


@@ -101,23 +100,19 @@ static struct children *ignore_destroying_bit(struct children *parent_child)
 }
 
 /* This means valgrind can see leaks. */
 }
 
 /* This means valgrind can see leaks. */

-static void tal_cleanup(void)
+void tal_cleanup(void)

 {
        struct tal_hdr *i;
 
 {
        struct tal_hdr *i;
 

-       while ((i = list_top(&null_parent.c.children, struct tal_hdr, list)))
+       while ((i = list_top(&null_parent.c.children, struct tal_hdr, list))) {

                list_del(&i->list);
                list_del(&i->list);

+               memset(i, 0, sizeof(*i));
+       }

 
        /* Cleanup any taken pointers. */
        take_cleanup();
 }
 
 
        /* Cleanup any taken pointers. */
        take_cleanup();
 }
 

-/* For allocation failures inside ccan/take */
-static void take_alloc_failed(const void *p)
-{
-       tal_free(p);
-}
-

 /* We carefully start all real properties with a zero byte. */
 static bool is_literal(const struct prop_hdr *prop)
 {
 /* We carefully start all real properties with a zero byte. */
 static bool is_literal(const struct prop_hdr *prop)
 {


@@ -327,18 +322,6 @@ static struct name *add_name_property(struct tal_hdr *t, const char *name)
        return prop;
 }
 
        return prop;
 }
 

-static struct length *add_length_property(struct tal_hdr *t, size_t count)
-{
-       struct length *prop;
-
-       prop = allocate(sizeof(*prop));
-       if (prop) {
-               init_property(&prop->hdr, t, LENGTH);
-               prop->count = count;
-       }
-       return prop;
-}
-

 static struct children *add_child_property(struct tal_hdr *parent,
                                           struct tal_hdr *child)
 {
 static struct children *add_child_property(struct tal_hdr *parent,
                                           struct tal_hdr *child)
 {


@@ -356,11 +339,6 @@ static bool add_child(struct tal_hdr *parent, struct tal_hdr *child)
        struct children *children = find_property(parent, CHILDREN);
 
         if (!children) {
        struct children *children = find_property(parent, CHILDREN);
 
         if (!children) {

-               if (unlikely(!initialized)) {
-                       atexit(tal_cleanup);
-                       take_allocfail(take_alloc_failed);
-                       initialized = true;
-               }

                children = add_child_property(parent, child);
                if (!children)
                        return false;
                children = add_child_property(parent, child);
                if (!children)
                        return false;


@@ -398,21 +376,50 @@ static void del_tree(struct tal_hdr *t, const tal_t *orig)
         /* Finally free our properties. */
         for (p = t->prop; p && !is_literal(p); p = next) {
                 next = p->next;
         /* Finally free our properties. */
         for (p = t->prop; p && !is_literal(p); p = next) {
                 next = p->next;

-               freefn(p);
+               /* LENGTH is appended, so don't free separately! */
+               if (p->type != LENGTH)
+                       freefn(p);

         }
         freefn(t);
 }
 
         }
         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));
 
         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)
         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;
         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;
         if (!add_child(parent, child)) {
                freefn(child);
                return NULL;


@@ -425,14 +432,16 @@ void *tal_alloc_(const tal_t *ctx, size_t size, bool clear, const char *label)
 
 static bool adjust_size(size_t *size, size_t count)
 {
 
 static bool adjust_size(size_t *size, size_t count)
 {

+       const size_t extra = sizeof(struct tal_hdr) + sizeof(struct length)*2;
+

        /* Multiplication wrap */
         if (count && unlikely(*size * count / *size != count))
                goto overflow;
 
         *size *= count;
 
        /* Multiplication wrap */
         if (count && unlikely(*size * count / *size != count))
                goto overflow;
 
         *size *= count;
 

-        /* Make sure we don't wrap adding header. */
-        if (*size + sizeof(struct tal_hdr) < sizeof(struct tal_hdr))
+        /* Make sure we don't wrap adding header/tailer. */
+        if (*size + extra < extra)

                goto overflow;
        return true;
 overflow:
                goto overflow;
        return true;
 overflow:


@@ -441,19 +450,12 @@ overflow:
 }
 
 void *tal_alloc_arr_(const tal_t *ctx, size_t size, size_t count, bool clear,
 }
 
 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 (!adjust_size(&size, count))
                return NULL;
 

-       ret = tal_alloc_(ctx, size, clear, label);
-       if (likely(ret) && add_count) {
-               if (unlikely(!add_length_property(to_tal_hdr(ret), count)))
-                       ret = tal_free(ret);
-       }
-       return ret;
+       return tal_alloc_(ctx, size, clear, add_length, label);

 }
 
 void *tal_free(const tal_t *ctx)
 }
 
 void *tal_free(const tal_t *ctx)


@@ -597,14 +599,14 @@ const char *tal_name(const tal_t *t)
        return n->name;
 }
 
        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;
 {
        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. */
 }
 
 /* Start one past first child: make stopping natural in circ. list. */


@@ -629,31 +631,16 @@ tal_t *tal_first(const tal_t *root)
        return from_tal_hdr(c);
 }
 
        return from_tal_hdr(c);
 }
 

-tal_t *tal_next(const tal_t *root, const tal_t *prev)
+tal_t *tal_next(const tal_t *prev)

 {
 {

-        struct tal_hdr *c, *t = debug_tal(to_tal_hdr(prev)), *top;
+        struct tal_hdr *next, *prevhdr = debug_tal(to_tal_hdr(prev));
+       struct list_head *head;

 
 

-        /* Children? */
-       c = first_child(t);
-       if (c)
-               return from_tal_hdr(c);
-
-        top = to_tal_hdr_or_null(root);
-        do {
-               struct tal_hdr *next;
-               struct list_node *end;
-
-               end = &ignore_destroying_bit(t->parent_child)->children.n;
-
-               next = list_entry(t->list.next, struct tal_hdr, list);
-               if (&next->list != end)
-                       return from_tal_hdr(next);
-
-                /* OK, go back to parent. */
-                t = ignore_destroying_bit(t->parent_child)->parent;
-        } while (t != top);
-
-        return NULL;
+       head = &ignore_destroying_bit(prevhdr->parent_child)->children;
+       next = list_next(head, prevhdr, list);
+       if (!next)
+               return NULL;
+       return from_tal_hdr(next);

 }
 
 tal_t *tal_parent(const tal_t *ctx)
 }
 
 tal_t *tal_parent(const tal_t *ctx)


@@ -669,30 +656,61 @@ tal_t *tal_parent(const tal_t *ctx)
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 
         return from_tal_hdr(ignore_destroying_bit(t->parent_child)->parent);
 }
 

-bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
+bool tal_resize_(tal_t **ctxp, size_t size, size_t count, bool clear)

 {
         struct tal_hdr *old_t, *t;
         struct children *child;
 {
         struct tal_hdr *old_t, *t;
         struct children *child;

-       struct length *len;
+       struct prop_hdr **lenp;
+       struct length len;
+       size_t extra = 0;

 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
        if (!adjust_size(&size, count))
                return false;
 
 
         old_t = debug_tal(to_tal_hdr(*ctxp));
 
        if (!adjust_size(&size, count))
                return false;
 

-        t = resizefn(old_t, size + sizeof(struct tal_hdr));
+       lenp = find_property_ptr(old_t, LENGTH);
+       if (lenp) {
+               /* Copy here, in case we're shrinking! */
+               len = *(struct length *)*lenp;
+               extra = extra_for_length(size);
+       } else /* If we don't have an old length, we can't clear! */
+               assert(!clear);
+
+        t = resizefn(old_t, sizeof(struct tal_hdr) + size + extra);

        if (!t) {
                call_error("Reallocation failure");
                return false;
        }
 
        if (!t) {
                call_error("Reallocation failure");
                return false;
        }
 

+       /* Copy length to end. */
+       if (lenp) {
+               struct length *new_len;
+
+               /* Clear between old end and new end. */
+               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
+                                           + extra - sizeof(len));
+               len.len = size;
+               *new_len = len;
+
+               /* Be careful replacing next ptr; could be old hdr. */
+               if (lenp == &old_t->prop)
+                       t->prop = &new_len->hdr;
+               else
+                       *lenp = &new_len->hdr;
+       }
+
+       update_bounds(t, sizeof(struct tal_hdr) + size + extra);
+

        /* If it didn't move, we're done! */
         if (t != old_t) {
        /* If it didn't move, we're done! */
         if (t != old_t) {

-               update_bounds(t, size + sizeof(struct tal_hdr));
-

                /* Fix up linked list pointers. */
                /* 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;
+               t->list.next->prev = t->list.prev->next = &t->list;

 
                /* Fix up child property's parent pointer. */
                child = find_property(t, CHILDREN);
 
                /* Fix up child property's parent pointer. */
                child = find_property(t, CHILDREN);


@@ -704,43 +722,45 @@ bool tal_resize_(tal_t **ctxp, size_t size, size_t count)
                if (notifiers)
                        notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
        }
                if (notifiers)
                        notify(t, TAL_NOTIFY_MOVE, from_tal_hdr(old_t));
        }

-       len = find_property(t, LENGTH);
-       if (len)
-               len->count = count;

        if (notifiers)
                notify(t, TAL_NOTIFY_RESIZE, (void *)size);
 
        return true;
 }
 
        if (notifiers)
                notify(t, TAL_NOTIFY_RESIZE, (void *)size);
 
        return true;
 }
 

-char *tal_strdup(const tal_t *ctx, const char *p)
+bool tal_expand_(tal_t **ctxp, const void *src, size_t size, size_t count)

 {
 {

-       /* We have to let through NULL for take(). */
-       return tal_dup_(ctx, p, 1, p ? strlen(p) + 1: 1, 0, false,
-                       TAL_LABEL(char, "[]"));
-}
+       struct length *l;
+       size_t old_len;
+       bool ret = false;

 
 

-char *tal_strndup(const tal_t *ctx, const char *p, size_t n)
-{
-       size_t len;
-       char *ret;
+       l = find_property(debug_tal(to_tal_hdr(*ctxp)), LENGTH);
+       old_len = l->len;

 
 

-       /* We have to let through NULL for take(). */
-       if (likely(p)) {
-               len = strlen(p);
-               if (len > n)
-                       len = n;
-       } else
-               len = n;
+       /* Check for additive overflow */
+       if (old_len + count * size < old_len) {
+               call_error("dup size overflow");
+               goto out;
+       }

 
 

-       ret = tal_dup_(ctx, p, 1, len, 1, false, TAL_LABEL(char, "[]"));
-       if (ret)
-               ret[len] = '\0';
+       /* Don't point src inside thing we're expanding! */
+       assert(src < *ctxp
+              || (char *)src >= (char *)(*ctxp) + old_len);
+
+       if (!tal_resize_(ctxp, size, old_len/size + count, false))
+               goto out;
+
+       memcpy((char *)*ctxp + old_len, src, count * size);
+       ret = true;
+
+out:
+       if (taken(src))
+               tal_free(src);

        return ret;
 }
 
 void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
        return ret;
 }
 
 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;
               const char *label)
 {
        void *ret;


@@ -763,60 +783,19 @@ void *tal_dup_(const tal_t *ctx, const void *p, size_t size,
        if (taken(p)) {
                if (unlikely(!p))
                        return NULL;
        if (taken(p)) {
                if (unlikely(!p))
                        return NULL;

-               if (unlikely(!tal_resize_((void **)&p, size, n + extra)))
+               if (unlikely(!tal_resize_((void **)&p, size, n + extra, false)))

                        return tal_free(p);
                if (unlikely(!tal_steal(ctx, p)))
                        return tal_free(p);
                return (void *)p;
        }
 
                        return tal_free(p);
                if (unlikely(!tal_steal(ctx, p)))
                        return tal_free(p);
                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;
 }
 
        if (ret)
                memcpy(ret, p, nbytes);
        return ret;
 }
 

-char *tal_asprintf(const tal_t *ctx, const char *fmt, ...)
-{
-       va_list ap;
-       char *ret;
-
-       va_start(ap, fmt);
-       ret = tal_vasprintf(ctx, fmt, ap);
-       va_end(ap);
-
-       return ret;
-}
-
-char *tal_vasprintf(const tal_t *ctx, const char *fmt, va_list ap)
-{
-       size_t max;
-       char *buf;
-       int ret;
-
-       if (!fmt && taken(fmt))
-               return NULL;
-
-       /* A decent guess to start. */
-       max = strlen(fmt) * 2;
-       buf = tal_arr(ctx, char, max);
-       while (buf) {
-               va_list ap2;
-
-               va_copy(ap2, ap);
-               ret = vsnprintf(buf, max, fmt, ap2);
-               va_end(ap2);
-
-               if (ret < max)
-                       break;
-               if (!tal_resize(&buf, max *= 2))
-                       buf = tal_free(buf);
-       }
-       if (taken(fmt))
-               tal_free(fmt);
-       return buf;
-}
-

 void tal_set_backend(void *(*alloc_fn)(size_t size),
                     void *(*resize_fn)(void *, size_t size),
                     void (*free_fn)(void *),
 void tal_set_backend(void *(*alloc_fn)(size_t size),
                     void *(*resize_fn)(void *, size_t size),
                     void (*free_fn)(void *),


@@ -867,7 +846,7 @@ static void dump_node(unsigned int indent, const struct tal_hdr *t)
                        break;
                case LENGTH:
                        l = (struct length *)p;
                        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);
                        break;
                default:
                        printf(" **UNKNOWN(%p):%i**", p, p->type);


@@ -929,7 +908,6 @@ static bool check_node(struct children *parent_child,
                        if (name)
                                return check_err(t, errorstr,
                                                 "has extra literal");
                        if (name)
                                return check_err(t, errorstr,
                                                 "has extra literal");

-                       name = (struct name *)p;

                        break;
                }
                if (!in_bounds(p))
                        break;
                }
                if (!in_bounds(p))