Introducing various astobj2 enhancements, chief being a refcount tracing feature, and various documentation updates in astobj2.h, and the addition of standalone utility, refcounter, that will filter the trace output for unbalanced, unfreed objects. This comes from the team/murf/bug11210 branch.

git-svn-id: http://svn.digium.com/svn/asterisk/trunk@114175 f38db490-d61c-443f-a65b-d21fe96a405b

2 files changed, 274 insertions, 2 deletions

diff --git a/utils/Makefile b/utils/Makefile
index 9576cb5b0..d84907710 100644
--- a/utils/Makefile
+++ b/utils/Makefile
@@ -17,7 +17,7 @@ ASTTOPDIR?=..
 .PHONY: clean all uninstall
 
 # to get check_expr, add it to the ALL_UTILS list
-ALL_UTILS:=astman smsq stereorize streamplayer aelparse muted check_expr conf2ael hashtest2 hashtest astcanary
+ALL_UTILS:=astman smsq stereorize streamplayer aelparse muted check_expr conf2ael hashtest2 hashtest astcanary refcounter
 UTILS:=$(ALL_UTILS)
 
 LIBS += $(BKTR_LIB)	# astobj2 with devmode uses backtrace
@@ -76,7 +76,7 @@ clean:
 	rm -f *.s *.i
 	rm -f md5.c strcompat.c ast_expr2.c ast_expr2f.c pbx_ael.c pval.c hashtab.c
 	rm -f aelparse.c aelbison.c conf2ael
-	rm -f utils.c threadstorage.c sha1.c astobj2.c hashtest2 hashtest
+	rm -f utils.c threadstorage.c sha1.c astobj2.c hashtest2 hashtest refcounter
 
 md5.c: $(ASTTOPDIR)/main/md5.c
 	@cp $< $@
@@ -153,6 +153,10 @@ hashtest: hashtest.o md5.o hashtab.o utils.o sha1.o strcompat.o threadstorage.o
 
 hashtest.o: ASTCFLAGS+=-O0
 
+refcounter: refcounter.o md5.o hashtab.o utils.o sha1.o strcompat.o threadstorage.o clicompat.o
+
+refcounter.o: ASTCFLAGS+=-O0
+
 extconf.o: extconf.c
 
 conf2ael: conf2ael.o ast_expr2f.o ast_expr2.o hashtab.o aelbison.o aelparse.o pbx_ael.o pval.o extconf.o strcompat.o
diff --git a/utils/refcounter.c b/utils/refcounter.c
new file mode 100644
index 000000000..4c3e96e3b
--- /dev/null
+++ b/utils/refcounter.c
@@ -0,0 +1,268 @@
+/*
+ * Asterisk -- An open source telephony toolkit.
+ *
+ * Copyright (C) 2008, Steve Murphy
+ *
+ * Steve Murphy <murf@digium.com>
+ *
+ * See http://www.asterisk.org for more information about
+ * the Asterisk project. Please do not directly contact
+ * any of the maintainers of this project for assistance;
+ * the project provides a web site, mailing lists and IRC
+ * channels for your use.
+ *
+ * This program is free software, distributed under the terms of
+ * the GNU General Public License Version 2. See the LICENSE file
+ * at the top of the source tree.
+ */
+/*! \file
+ *
+ *  \brief A program to read in the /tmp/refs file generated
+ *         by astobj2 code when the REF_DEBUG macro is defined.
+ *         It will read in the file line by line, and
+ *         sort the data out by object, and check to see
+ *         if the refcounts balance to zero, and the object
+ *         was destroyed just once. Any problems that are 
+ *         found are reported to stdout and the objects
+ *         ref count history is printed out. If all is well,
+ *         this program reads in the /tmp/refs file and 
+ *         generates no output. No news is good news.
+ *  The contents of the /tmp/refs file looks like this:
+ *
+0x84fd718 -1   astobj2.c:926:cd_cb_debug (deref object via container destroy) [@1]
+0x84fd718 =1   chan_sip.c:19760:build_user (allocate a user struct)
+0x84fd718 +1   chan_sip.c:21558:reload_config (link user into users table) [@1]
+0x84fd718 -1   chan_sip.c:2376:unref_user (Unref the result of build_user. Now, the table link is the only one left.) [@2]
+0x84fd718 **call destructor** astobj2.c:926:cd_cb_debug (deref object via container destroy)
+ *
+ *
+ *  \author Steve Murphy <murf@digium.com>
+ */
+
+#include "asterisk.h"
+ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
+
+#include <pthread.h>
+#include <sys/stat.h>
+#include <signal.h>
+#include <errno.h>
+#include "asterisk/lock.h"
+#include "asterisk/hashtab.h"
+#include "asterisk/channel.h"
+#include "asterisk/utils.h"
+#include "asterisk/module.h"
+
+struct rc_hist
+{
+	char *desc;
+	struct rc_hist *next;
+};
+
+struct rc_obj /* short for refcounted object */
+{
+	unsigned int addr;
+	unsigned int count;  /* this plus addr makes each entry unique, starts at 1 */
+	int last_count; /* count 1 objects will record how many other objects had the same addr */
+	int destroy_count;
+	int total_refcount;
+	struct rc_hist *hist;
+	struct rc_hist *last;
+};
+
+static unsigned int hashtab_hash_rc(const void *obj)
+{
+	const struct rc_obj *rc = obj;
+	return rc->addr + rc->count; /* it's addr will make a FINE hash */
+}
+
+static int hashtab_compare_rc(const void *a, const void *b)
+{
+	const struct rc_obj *rca = a;
+	const struct rc_obj *rcb = b;
+	if (rca->addr == rcb->addr && rca->count == rcb->count)
+		return 0;
+	else
+		return 1;
+}
+
+
+static struct rc_obj *alloc_obj(unsigned int addr, unsigned int count)
+{
+	struct rc_obj *x = calloc(1,sizeof(struct rc_obj));
+	x->addr = addr;
+	x->count = count;
+	x->last_count = 1;
+	x->total_refcount = 1;
+	return x;
+}
+
+static void add_to_hist(char *buffer, struct rc_obj *obj)
+{
+	struct rc_hist *y = calloc(1,sizeof(struct rc_hist));
+	y->desc = strdup(buffer);
+	if (obj->last) {
+		obj->last->next = y;
+		obj->last = y;
+	} else {
+		obj->hist = obj->last = y;
+	}
+}
+
+
+
+int main(int argc,char **argv)
+{
+	char linebuffer[300];
+	FILE *ifile = fopen("/tmp/refs", "r");
+	char *t;
+	unsigned int un;
+	struct rc_obj *curr_obj, *count1_obj;
+	struct rc_obj lookup;
+	struct ast_hashtab_iter *it;
+	struct ast_hashtab *objhash;
+	
+	if (!ifile) {
+		printf("Sorry, Cannot open /tmp/refs!\n");
+		exit(10);
+	}
+	
+	objhash = ast_hashtab_create(9000, hashtab_compare_rc, ast_hashtab_resize_java, ast_hashtab_newsize_java, hashtab_hash_rc, 1);
+	
+	while (fgets(linebuffer, sizeof(linebuffer), ifile)) {
+		/* collect data about the entry */
+		un = strtoul(linebuffer, &t, 16);
+		lookup.addr = un;
+		lookup.count = 1;
+
+		count1_obj = ast_hashtab_lookup(objhash, &lookup);
+		
+		if (count1_obj) {
+			/* there IS a count1 obj, so let's see which one we REALLY want */
+			if (*(t+1) == '=') {
+				/* start a new object! */
+				curr_obj = alloc_obj(un, ++count1_obj->last_count);
+				/* put it in the hashtable */
+				ast_hashtab_insert_safe(objhash, curr_obj);
+			} else {
+				if (count1_obj->last_count > 1) {
+					lookup.count = count1_obj->last_count;
+					curr_obj = ast_hashtab_lookup(objhash, &lookup);
+				} else {
+					curr_obj = count1_obj;
+				}
+				
+			}
+
+		} else {
+			/* NO obj at ALL? -- better make one! */
+			if (*(t+1) != '=') {
+				printf("BAD: object %x appears without previous allocation marker!\n", count1_obj->addr);
+			}
+			curr_obj = count1_obj = alloc_obj(un, 1);
+			/* put it in the hashtable */
+			ast_hashtab_insert_safe(objhash, curr_obj);
+			
+		}
+		
+		if (*(t+1) == '+' || *(t+1) == '-' ) {
+			curr_obj->total_refcount += strtol(t+1, NULL, 10);
+		} else if (*(t+1) == '*') {
+			curr_obj->destroy_count++;
+		}
+		
+		add_to_hist(linebuffer, curr_obj);
+	}
+	fclose(ifile);
+	
+	/* traverse the objects and check for problems */
+	it = ast_hashtab_start_traversal(objhash);
+	while ((curr_obj = ast_hashtab_next(it))) {
+		if (curr_obj->total_refcount != 0 || curr_obj->destroy_count != 1) {
+			struct rc_hist *h;
+			if (curr_obj->total_refcount != 0)
+				printf("Problem: net Refcount not zero for object %x\n", curr_obj->addr);
+			if (curr_obj->destroy_count > 1 )
+				printf("Problem: Object %x destroyed more than once!\n", curr_obj->addr);
+			printf("Object %x history:\n", curr_obj->addr);
+			for(h=curr_obj->hist;h;h=h->next) {
+				printf("   %s", h->desc);
+			}
+			printf("==============\n");
+		}
+	}
+	ast_hashtab_end_traversal(it);
+	return 0;
+}
+
+
+/* stub routines to satisfy linking with asterisk subcomponents */
+
+int  ast_add_profile(const char *x, uint64_t scale)
+{
+	return 0;
+}
+
+int ast_loader_register(int (*updater)(void))
+{
+	return 1;
+}
+
+int ast_loader_unregister(int (*updater)(void))
+{
+	return 1;
+}
+void ast_module_register(const struct ast_module_info *x)
+{
+}
+
+void ast_module_unregister(const struct ast_module_info *x)
+{
+}
+
+
+void ast_register_file_version(const char *file, const char *version)
+{
+}
+
+void ast_unregister_file_version(const char *file)
+{
+
+}
+
+#undef ast_mark
+
+int64_t ast_mark(int x, int start1_stop0)
+{
+	return 0;
+}
+
+void ast_log(int level, const char *file, int line, const char *function, const char *fmt, ...)
+{
+	va_list vars;
+	va_start(vars,fmt);
+	printf("LOG: lev:%d file:%s  line:%d func: %s  ",
+		   level, file, line, function);
+	vprintf(fmt, vars);
+	fflush(stdout);
+	va_end(vars);
+}
+
+void ast_verbose(const char *fmt, ...)
+{
+        va_list vars;
+        va_start(vars,fmt);
+
+        printf("VERBOSE: ");
+        vprintf(fmt, vars);
+        fflush(stdout);
+        va_end(vars);
+}
+
+void ast_register_thread(char *name)
+{
+
+}
+
+void ast_unregister_thread(void *id)
+{
+}