Changeset 746 for vendor/current/lib/talloc

Timestamp:

Nov 27, 2012, 4:56:06 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated vendor to 3.6.9

Location:

vendor/current/lib/talloc

Files:

• talloc.3.xml (modified) (1 diff)
• talloc.c (modified) (5 diffs)
• talloc.h (modified) (10 diffs)
• talloc_guide.txt (modified) (13 diffs)
• testsuite.c (modified) (2 diffs)

vendor/current/lib/talloc/talloc.3.xml

@@ -784 +784 @@
     <para>
       This program is free software; you can redistribute it and/or modify
-      it under the terms of the GNU General Public License as published by
-      the Free Software Foundation; either version 3 of the License, or (at
-      your option) any later version.
+      it under the terms of the GNU Lesser General Public License as
+      published by the Free Software Foundation; either version 3 of the
+      License, or (at your option) any later version.
     </para>
     <para>

vendor/current/lib/talloc/talloc.c

@@ -839 +839 @@
                 if (tc->prev) tc->prev->next = tc->next;
                 if (tc->next) tc->next->prev = tc->prev;
+                tc->prev = tc->next = NULL;
         }
 
@@ -926 +927 @@
                 if (tc->prev) tc->prev->next = tc->next;
                 if (tc->next) tc->next->prev = tc->prev;
+                tc->prev = tc->next = NULL;
         }
 
@@ -1252 +1254 @@
                         if (p) new_parent = TC_PTR_FROM_CHUNK(p);
                 }
-                /* finding the parent here is potentially quite
-                   expensive, but the alternative, which is to change
-                   talloc to always have a valid tc->parent pointer,
-                   makes realloc more expensive where there are a
-                   large number of children.
-
-                   The reason we need the parent pointer here is that
-                   if _talloc_free_internal() fails due to references
-                   or a failing destructor we need to re-parent, but
-                   the free call can invalidate the prev pointer.
-                */
-                if (new_parent == null_context && (tc->child->refs || tc->child->destructor)) {
-                        old_parent = talloc_parent_chunk(ptr);
-                }
                 if (unlikely(_talloc_free_internal(child, location) == -1)) {
                         if (new_parent == null_context) {
-                                struct talloc_chunk *p = old_parent;
+                                struct talloc_chunk *p = talloc_parent_chunk(ptr);
                                 if (p) new_parent = TC_PTR_FROM_CHUNK(p);
                         }
@@ -1283 +1271 @@
 _PUBLIC_ void talloc_free_children(void *ptr)
 {
+        struct talloc_chunk *tc_name = NULL;
         struct talloc_chunk *tc;
 
@@ -1291 +1280 @@
         tc = talloc_chunk_from_ptr(ptr);
 
+        /* we do not want to free the context name if it is a child .. */
+        if (likely(tc->child)) {
+                for (tc_name = tc->child; tc_name; tc_name = tc_name->next) {
+                        if (tc->name == TC_PTR_FROM_CHUNK(tc_name)) break;
+                }
+                if (tc_name) {
+                        _TLIST_REMOVE(tc->child, tc_name);
+                        if (tc->child) {
+                                tc->child->parent = tc;
+                        }
+                }
+        }
+
         _talloc_free_children_internal(tc, ptr, __location__);
+
+        /* .. so we put it back after all other children have been freed */
+        if (tc_name) {
+                if (tc->child) {
+                        tc->child->parent = NULL;
+                }
+                tc_name->parent = tc;
+                _TLIST_ADD(tc->child, tc_name);
+        }
 }
 

vendor/current/lib/talloc/talloc.h

@@ -174 +174 @@
  * no modifications and return -1.
  *
- * If this pointer has an additional parent when talloc_free() is called
- * then the memory is not actually released, but instead the most
- * recently established parent is destroyed. See talloc_reference() for
- * details on establishing additional parents.
- *
- * For more control on which parent is removed, see talloc_unlink()
- *
- * talloc_free() operates recursively on its children.
- *
- * From the 2.0 version of talloc, as a special case, talloc_free() is
- * refused on pointers that have more than one parent, as talloc would
- * have no way of knowing which parent should be removed. To free a
+ * From version 2.0 and onwards, as a special case, talloc_free() is
+ * refused on pointers that have more than one parent associated, as talloc
+ * would have no way of knowing which parent should be removed. This is
+ * different from older versions in the sense that always the reference to
+ * the most recently established parent has been destroyed. Hence to free a
  * pointer that has more than one parent please use talloc_unlink().
  *
@@ -201 +194 @@
  * talloc_set_log_stderr() for more information on talloc logging
  * functions.
+ *
+ * talloc_free() operates recursively on its children.
  *
  * @param[in]  ptr      The chunk to be freed.
@@ -234 +229 @@
  * talloc_free()s only the children, not the context itself.
  *
- * @param[in]  ptr      The chunk that you want to free the children of.
+ * A NULL argument is handled as no-op.
+ *
+ * @param[in]  ptr      The chunk that you want to free the children of
+ *                      (NULL is allowed too)
  */
 void talloc_free_children(void *ptr);
@@ -403 +401 @@
  * @param[in]  new_ctx  The new parent context.
  *
- * @param[in]  ptr      Pointer to the talloc chunk to move.
+ * @param[in]  pptr     Pointer to the talloc chunk to move.
  *
  * @return              The pointer of the talloc chunk it has been moved to,
  *                      NULL on error.
  */
-void *talloc_move(const void *new_ctx, const void *ptr);
-#else
-#define talloc_move(ctx, ptr) (_TALLOC_TYPEOF(*(ptr)))_talloc_move((ctx),(void *)(ptr))
+void *talloc_move(const void *new_ctx, void **pptr);
+#else
+#define talloc_move(ctx, pptr) (_TALLOC_TYPEOF(*(pptr)))_talloc_move((ctx),(void *)(pptr))
 void *_talloc_move(const void *new_ctx, const void *pptr);
 #endif
@@ -703 +701 @@
  * @brief Assign a type to a talloc chunk.
  *
- * This macro allows you to force the name of a pointer to be a particular type.
- * This can be used in conjunction with talloc_get_type() to do type checking on
- * void* pointers.
+ * This macro allows you to force the name of a pointer to be of a particular
+ * type. This can be used in conjunction with talloc_get_type() to do type
+ * checking on void* pointers.
  *
  * It is equivalent to this:
@@ -906 +904 @@
  *   cause this pointer to be freed if it runs out of parents.
  *
- * - you can talloc_free() the pointer itself. That will destroy the
- *   most recently established parent to the pointer and leave the
- *   pointer as a child of its current parent.
+ * - you can talloc_free() the pointer itself if it has at maximum one
+ *   parent. This behaviour has been changed since the release of version
+ *   2.0. Further informations in the description of "talloc_free".
  *
  * For more control on which parent to remove, see talloc_unlink()
@@ -943 +941 @@
  * a direct parent of ptr.
  *
- * Usually you can just use talloc_free() instead of talloc_unlink(), but
- * sometimes it is useful to have the additional control on which parent is
- * removed.
+ * You can just use talloc_free() instead of talloc_unlink() if there
+ * is at maximum one parent. This behaviour has been changed since the
+ * release of version 2.0. Further informations in the description of
+ * "talloc_free".
  *
  * @param[in]  context  The talloc parent to remove.
@@ -993 +992 @@
  * @brief Get the size of a talloc chunk.
  *
- * This function lets you know the amount of memory alloced so far by
+ * This function lets you know the amount of memory allocated so far by
  * this context. It does NOT account for subcontext memory.
  * This can be used to calculate the size of an array.
@@ -1454 +1453 @@
  *
  * This function appends the given formatted string to the given string. Use
- * this varient when the string in the current talloc buffer may have been
+ * this variant when the string in the current talloc buffer may have been
  * truncated in length.
  *
@@ -1552 +1551 @@
  *
  * This provides a more detailed report than talloc_report(). It will
- * recursively print the ensire tree of memory referenced by the
+ * recursively print the entire tree of memory referenced by the
  * pointer. References in the tree are shown by giving the name of the
  * pointer that is referenced.

vendor/current/lib/talloc/talloc_guide.txt

@@ -27 +27 @@
 
 and the pointer X->name would be a "child" of the talloc context "X"
-which is itself a child of mem_ctx. So if you do talloc_free(mem_ctx)
+which is itself a child of "mem_ctx". So if you do talloc_free(mem_ctx)
 then it is all destroyed, whereas if you do talloc_free(X) then just X
 and X->name are destroyed, and if you do talloc_free(X->name) then
@@ -65 +65 @@
 the underlying "malloc" is), as long as each thread uses different  
 memory contexts.
-If two threads uses the same context then they need to synchronize in  
+If two threads use the same context then they need to synchronize in
 order to be safe. In particular:
 - when using talloc_enable_leak_report(), giving directly NULL as a  
@@ -137 +137 @@
 no modifications and returns -1.
 
-If this pointer has an additional parent when talloc_free() is called
-then the memory is not actually released, but instead the most
-recently established parent is destroyed. See talloc_reference() for
-details on establishing additional parents.
-
-For more control on which parent is removed, see talloc_unlink()
-
-talloc_free() operates recursively on its children.
-
-From the 2.0 version of talloc, as a special case, talloc_free() is
-refused on pointers that have more than one parent, as talloc would
-have no way of knowing which parent should be removed. To free a
+From version 2.0 and onwards, as a special case, talloc_free() is
+refused on pointers that have more than one parent associated, as talloc
+would have no way of knowing which parent should be removed. This is
+different from older versions in the sense that always the reference to
+the most recently established parent has been destroyed. Hence to free a
 pointer that has more than one parent please use talloc_unlink().
 
@@ -163 +156 @@
 functions.
 
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
-int talloc_free_children(void *ptr);
+talloc_free() operates recursively on its children.
+
+=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+void talloc_free_children(void *ptr);
 
 The talloc_free_children() walks along the list of all children of a
@@ -170 +165 @@
 itself.
 
+A NULL argument is handled as no-op.
 
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -191 +187 @@
     cause this pointer to be freed if it runs out of parents.
 
-  - you can talloc_free() the pointer itself. That will destroy the
-    most recently established parent to the pointer and leave the
-    pointer as a child of its current parent.
+  - you can talloc_free() the pointer itself if it has at maximum one
+    parent. This behaviour has been changed since the release of version
+    2.0. Further informations in the description of "talloc_free".
 
 For more control on which parent to remove, see talloc_unlink()
@@ -209 +205 @@
 is NULL, then the function will make no modifications and return -1.
 
-Usually you can just use talloc_free() instead of talloc_unlink(), but
-sometimes it is useful to have the additional control on which parent
-is removed.
-
+You can just use talloc_free() instead of talloc_unlink() if there
+is at maximum one parent. This behaviour has been changed since the
+release of version 2.0. Further informations in the description of
+"talloc_free".
 
 =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
@@ -484 +480 @@
 
 This provides a more detailed report than talloc_report(). It will
-recursively print the ensire tree of memory referenced by the
+recursively print the entire tree of memory referenced by the
 pointer. References in the tree are shown by giving the name of the
 pointer that is referenced.
@@ -643 +639 @@
 The talloc_asprintf_append() function appends the given formatted
 string to the given string.
-Use this varient when the string in the current talloc buffer may
+Use this variant when the string in the current talloc buffer may
 have been truncated in length.
 
@@ -657 +653 @@
 The talloc_asprintf_append() function appends the given formatted 
 string to the end of the currently allocated talloc buffer.
-Use this varient when the string in the current talloc buffer has
+Use this variant when the string in the current talloc buffer has
 not been changed.
 
@@ -731 +727 @@
 talloc_set_type(const void *ptr, type);
 
-This macro allows you to force the name of a pointer to be a
+This macro allows you to force the name of a pointer to be of a
 particular type. This can be used in conjunction with
 talloc_get_type() to do type checking on void* pointers.
@@ -742 +738 @@
 talloc_get_size(const void *ctx);
 
-This function lets you know the amount of memory alloced so far by
+This function lets you know the amount of memory allocated so far by
 this context. It does NOT account for subcontext memory.
 This can be used to calculate the size of an array.
@@ -769 +765 @@
 void talloc_set_log_stderr(void)
 
-This sets the talloc log function to write log messages to stderr
+This sets the talloc log function to write log messages to stderr.

vendor/current/lib/talloc/testsuite.c

@@ -1318 +1318 @@
         talloc_report_full(root, stdout);
         talloc_free(root);
+        CHECK_BLOCKS("null_context", NULL, 2);
+        return true;
+}
+
+static bool test_free_children(void)
+{
+        void *root;
+        const char *p1, *p2, *name, *name2;
+
+        talloc_enable_null_tracking();
+        root = talloc_new(NULL);
+        p1 = talloc_strdup(root, "foo1");
+        p2 = talloc_strdup(p1, "foo2");
+
+        talloc_set_name(p1, "%s", "testname");
+        talloc_free_children(p1);
+        /* check its still a valid talloc ptr */
+        talloc_get_size(talloc_get_name(p1));
+        if (strcmp(talloc_get_name(p1), "testname") != 0) {
+                return false;
+        }
+
+        talloc_set_name(p1, "%s", "testname");
+        name = talloc_get_name(p1);
+        talloc_free_children(p1);
+        /* check its still a valid talloc ptr */
+        talloc_get_size(talloc_get_name(p1));
+        torture_assert("name", name == talloc_get_name(p1), "name ptr changed");
+        torture_assert("namecheck", strcmp(talloc_get_name(p1), "testname") == 0,
+                       "wrong name");
+        CHECK_BLOCKS("name1", p1, 2);
+
+        /* note that this does not free the old child name */
+        talloc_set_name_const(p1, "testname2");
+        name2 = talloc_get_name(p1);
+        /* but this does */
+        talloc_free_children(p1);
+        torture_assert("namecheck", strcmp(talloc_get_name(p1), "testname2") == 0,
+                       "wrong name");
+        CHECK_BLOCKS("name1", p1, 1);
+
+        talloc_report_full(root, stdout);
+        talloc_free(root);
         return true;
 }
@@ -1380 +1423 @@
         test_reset();
         ret &= test_rusty();
+        test_reset();
+        ret &= test_free_children();
 
         if (ret) {