[Xen-changelog] [xen-unstable] xenstore: cleanups

[Xen patchbot-unstable <patchbot-unstable@xxxxxxxxxxxxxxxxxxx>]

# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1213102194 -3600
# Node ID 189597fbb8825fbeab758fdf49e31ec76af68102
# Parent  8a36f7f708596b8cbfcb83fa1e0723f0bf67ad60
xenstore: cleanups

Attached patch uses calloc() for hash allocation.
This makes sure, the allocated memory is always initialized.
Also cleanup error handling a bit.

On *BSD avoid conflicts with BSD list macros.

Signed-off-by: Christoph Egger <Christoph.Egger@xxxxxxx>
---
 tools/xenstore/hashtable.c |   25 +++++++++++++++++--------
 tools/xenstore/list.h      |    4 ++++
 2 files changed, 21 insertions(+), 8 deletions(-)

diff -r 8a36f7f70859 -r 189597fbb882 tools/xenstore/hashtable.c
--- a/tools/xenstore/hashtable.c        Tue Jun 10 13:49:02 2008 +0100
+++ b/tools/xenstore/hashtable.c        Tue Jun 10 13:49:54 2008 +0100
@@ -33,17 +33,22 @@ create_hashtable(unsigned int minsize,
 {
     struct hashtable *h;
     unsigned int pindex, size = primes[0];
+
     /* Check requested hashtable isn't too large */
     if (minsize > (1u << 30)) return NULL;
+
     /* Enforce size as prime */
     for (pindex=0; pindex < prime_table_length; pindex++) {
         if (primes[pindex] > minsize) { size = primes[pindex]; break; }
     }
-    h = (struct hashtable *)malloc(sizeof(struct hashtable));
-    if (NULL == h) return NULL; /*oom*/
-    h->table = (struct entry **)malloc(sizeof(struct entry*) * size);
-    if (NULL == h->table) { free(h); return NULL; } /*oom*/
-    memset(h->table, 0, size * sizeof(struct entry *));
+
+    h = (struct hashtable *)calloc(1, sizeof(struct hashtable));
+    if (NULL == h)
+        goto err0;
+    h->table = (struct entry **)calloc(size, sizeof(struct entry *));
+    if (NULL == h->table)
+        goto err1;
+
     h->tablelength  = size;
     h->primeindex   = pindex;
     h->entrycount   = 0;
@@ -51,6 +56,11 @@ create_hashtable(unsigned int minsize,
     h->eqfn         = eqf;
     h->loadlimit    = (unsigned int)(((uint64_t)size * max_load_factor) / 100);
     return h;
+
+err0:
+   free(h);
+err1:
+   return NULL;
 }
 
 /*****************************************************************************/
@@ -80,10 +90,9 @@ hashtable_expand(struct hashtable *h)
     if (h->primeindex == (prime_table_length - 1)) return 0;
     newsize = primes[++(h->primeindex)];
 
-    newtable = (struct entry **)malloc(sizeof(struct entry*) * newsize);
+    newtable = (struct entry **)calloc(newsize, sizeof(struct entry*));
     if (NULL != newtable)
     {
-        memset(newtable, 0, newsize * sizeof(struct entry *));
         /* This algorithm is not 'stable'. ie. it reverses the list
          * when it transfers entries between the tables */
         for (i = 0; i < h->tablelength; i++) {
@@ -149,7 +158,7 @@ hashtable_insert(struct hashtable *h, vo
          * element may be ok. Next time we insert, we'll try expanding again.*/
         hashtable_expand(h);
     }
-    e = (struct entry *)malloc(sizeof(struct entry));
+    e = (struct entry *)calloc(1, sizeof(struct entry));
     if (NULL == e) { --(h->entrycount); return 0; } /*oom*/
     e->h = hash(h,k);
     index = indexFor(h->tablelength,e->h);
diff -r 8a36f7f70859 -r 189597fbb882 tools/xenstore/list.h
--- a/tools/xenstore/list.h     Tue Jun 10 13:49:02 2008 +0100
+++ b/tools/xenstore/list.h     Tue Jun 10 13:49:54 2008 +0100
@@ -2,6 +2,10 @@
 #define _LINUX_LIST_H
 /* Taken from Linux kernel code, but de-kernelized for userspace. */
 #include <stddef.h>
+
+#undef LIST_HEAD_INIT
+#undef LIST_HEAD
+#undef INIT_LIST_HEAD
 
 /*
  * These are non-NULL pointers that will result in page faults

_______________________________________________
Xen-changelog mailing list
Xen-changelog@xxxxxxxxxxxxxxxxxxx
http://lists.xensource.com/xen-changelog