libxc: Code format cleanups.

Signed-off-by: Keir Fraser <keir@xensource.com>

1 files changed, 298 insertions, 285 deletions

diff --git a/tools/libxc/xc_dom_core.c b/tools/libxc/xc_dom_core.c
index ae64972ed5..ba11302e83 100644
--- a/tools/libxc/xc_dom_core.c
+++ b/tools/libxc/xc_dom_core.c
@@ -27,8 +27,8 @@ FILE *xc_dom_logfile = NULL;
 
 void xc_dom_loginit(void)
 {
-    if (xc_dom_logfile)
-	return;
+    if ( xc_dom_logfile )
+        return;
     xc_dom_logfile = fopen("/var/log/xen/domain-builder-ng.log", "a");
     setvbuf(xc_dom_logfile, NULL, _IONBF, 0);
     xc_dom_printf("### ----- xc domain builder logfile opened -----\n");
@@ -40,8 +40,8 @@ int xc_dom_printf(const char *fmt, ...)
     char buf[1024];
     int rc;
 
-    if (!xc_dom_logfile)
-	return 0;
+    if ( !xc_dom_logfile )
+        return 0;
 
     va_start(args, fmt);
     rc = vsnprintf(buf, sizeof(buf), fmt, args);
@@ -52,7 +52,7 @@ int xc_dom_printf(const char *fmt, ...)
 }
 
 int xc_dom_panic_func(const char *file, int line, xc_error_code err,
-		      const char *fmt, ...)
+                      const char *fmt, ...)
 {
     va_list args;
     FILE *fp = stderr;
@@ -60,8 +60,8 @@ int xc_dom_panic_func(const char *file, int line, xc_error_code err,
     char pos[256];
     char msg[XC_MAX_ERROR_MSG_LEN];
 
-    if (xc_dom_logfile)
-	fp = xc_dom_logfile;
+    if ( xc_dom_logfile )
+        fp = xc_dom_logfile;
 
     snprintf(pos, sizeof(pos), "%s:%d: panic: ", file, line);
     va_start(args, fmt);
@@ -74,12 +74,12 @@ int xc_dom_panic_func(const char *file, int line, xc_error_code err,
 
 static void print_mem(const char *name, size_t mem)
 {
-    if (mem > 32 * 1024 * 1024)
-	xc_dom_printf("%-24s : %zd MB\n", name, mem / (1024 * 1024));
-    else if (mem > 32 * 1024)
-	xc_dom_printf("%-24s : %zd kB\n", name, mem / 1024);
+    if ( mem > (32 * 1024 * 1024) )
+        xc_dom_printf("%-24s : %zd MB\n", name, mem / (1024 * 1024));
+    else if ( mem > (32 * 1024) )
+        xc_dom_printf("%-24s : %zd kB\n", name, mem / 1024);
     else
-	xc_dom_printf("%-24s : %zd bytes\n", name, mem);
+        xc_dom_printf("%-24s : %zd bytes\n", name, mem);
 }
 
 void xc_dom_log_memory_footprint(struct xc_dom_image *dom)
@@ -101,14 +101,14 @@ void *xc_dom_malloc(struct xc_dom_image *dom, size_t size)
     struct xc_dom_mem *block;
 
     block = malloc(sizeof(*block) + size);
-    if (NULL == block)
-	return NULL;
+    if ( block == NULL )
+        return NULL;
     memset(block, 0, sizeof(*block) + size);
     block->next = dom->memblocks;
     dom->memblocks = block;
     dom->alloc_malloc += sizeof(*block) + size;
-    if (size > 100 * 1024)
-	print_mem(__FUNCTION__, size);
+    if ( size > (100 * 1024) )
+        print_mem(__FUNCTION__, size);
     return block->memory;
 }
 
@@ -117,62 +117,63 @@ void *xc_dom_malloc_page_aligned(struct xc_dom_image *dom, size_t size)
     struct xc_dom_mem *block;
 
     block = malloc(sizeof(*block));
-    if (NULL == block)
-	return NULL;
+    if ( block == NULL )
+        return NULL;
     memset(block, 0, sizeof(*block));
     block->mmap_len = size;
     block->mmap_ptr = mmap(NULL, block->mmap_len,
-			   PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
-			   -1, 0);
-    if (MAP_FAILED == block->mmap_ptr)
+                           PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
+                           -1, 0);
+    if ( block->mmap_ptr == MAP_FAILED )
     {
-	free(block);
-	return NULL;
+        free(block);
+        return NULL;
     }
     block->next = dom->memblocks;
     dom->memblocks = block;
     dom->alloc_malloc += sizeof(*block);
     dom->alloc_mem_map += block->mmap_len;
-    if (size > 100 * 1024)
-	print_mem(__FUNCTION__, size);
+    if ( size > (100 * 1024) )
+        print_mem(__FUNCTION__, size);
     return block->mmap_ptr;
 }
 
 void *xc_dom_malloc_filemap(struct xc_dom_image *dom,
-			    const char *filename, size_t * size)
+                            const char *filename, size_t * size)
 {
     struct xc_dom_mem *block = NULL;
     int fd = -1;
 
     fd = open(filename, O_RDONLY);
-    if (-1 == fd)
-	goto err;
+    if ( fd == -1 )
+        goto err;
 
     lseek(fd, 0, SEEK_SET);
     *size = lseek(fd, 0, SEEK_END);
 
     block = malloc(sizeof(*block));
-    if (NULL == block)
-	goto err;
+    if ( block == NULL )
+        goto err;
     memset(block, 0, sizeof(*block));
     block->mmap_len = *size;
-    block->mmap_ptr = mmap(NULL, block->mmap_len, PROT_READ, MAP_SHARED, fd, 0);
-    if (MAP_FAILED == block->mmap_ptr)
-	goto err;
+    block->mmap_ptr = mmap(NULL, block->mmap_len, PROT_READ,
+                           MAP_SHARED, fd, 0);
+    if ( block->mmap_ptr == MAP_FAILED )
+        goto err;
     block->next = dom->memblocks;
     dom->memblocks = block;
     dom->alloc_malloc += sizeof(*block);
     dom->alloc_file_map += block->mmap_len;
     close(fd);
-    if (*size > 100 * 1024)
-	print_mem(__FUNCTION__, *size);
+    if ( *size > (100 * 1024) )
+        print_mem(__FUNCTION__, *size);
     return block->mmap_ptr;
 
-  err:
-    if (-1 != fd)
-	close(fd);
-    if (block)
-	free(block);
+ err:
+    if ( fd != -1 )
+        close(fd);
+    if ( block != NULL )
+        free(block);
     return NULL;
 }
 
@@ -180,12 +181,12 @@ static void xc_dom_free_all(struct xc_dom_image *dom)
 {
     struct xc_dom_mem *block;
 
-    while (NULL != (block = dom->memblocks))
+    while ( (block = dom->memblocks) != NULL )
     {
-	dom->memblocks = block->next;
-	if (block->mmap_ptr)
-	    munmap(block->mmap_ptr, block->mmap_len);
-	free(block);
+        dom->memblocks = block->next;
+        if ( block->mmap_ptr )
+            munmap(block->mmap_ptr, block->mmap_len);
+        free(block);
     }
 }
 
@@ -194,8 +195,8 @@ char *xc_dom_strdup(struct xc_dom_image *dom, const char *str)
     size_t len = strlen(str) + 1;
     char *nstr = xc_dom_malloc(dom, len);
 
-    if (NULL == nstr)
-	return NULL;
+    if ( nstr == NULL )
+        return NULL;
     memcpy(nstr, str, len);
     return nstr;
 }
@@ -208,18 +209,18 @@ size_t xc_dom_check_gzip(void *blob, size_t ziplen)
     unsigned char *gzlen;
     size_t unziplen;
 
-    if (0 != strncmp(blob, "\037\213", 2))
-	/* not gzipped */
-	return 0;
+    if (strncmp(blob, "\037\213", 2))
+        /* not gzipped */
+        return 0;
 
     gzlen = blob + ziplen - 4;
     unziplen = gzlen[3] << 24 | gzlen[2] << 16 | gzlen[1] << 8 | gzlen[0];
-    if (unziplen < ziplen || unziplen > ziplen * 8)
+    if ( (unziplen < ziplen) || (unziplen > (ziplen * 8)) )
     {
-	xc_dom_printf
-	    ("%s: size (zip %zd, unzip %zd) looks insane, skip gunzip\n",
-	     __FUNCTION__, ziplen, unziplen);
-	return 0;
+        xc_dom_printf
+            ("%s: size (zip %zd, unzip %zd) looks insane, skip gunzip\n",
+             __FUNCTION__, ziplen, unziplen);
+        return 0;
     }
 
     return unziplen + 16;
@@ -235,23 +236,23 @@ int xc_dom_do_gunzip(void *src, size_t srclen, void *dst, size_t dstlen)
     zStream.avail_in = srclen;
     zStream.next_out = dst;
     zStream.avail_out = dstlen;
-    rc = inflateInit2(&zStream, (MAX_WBITS + 32));	/* +32 means "handle gzip" */
-    if (rc != Z_OK)
+    rc = inflateInit2(&zStream, (MAX_WBITS + 32)); /* +32 means "handle gzip" */
+    if ( rc != Z_OK )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "%s: inflateInit2 failed (rc=%d)\n", __FUNCTION__, rc);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "%s: inflateInit2 failed (rc=%d)\n", __FUNCTION__, rc);
+        return -1;
     }
     rc = inflate(&zStream, Z_FINISH);
-    if (rc != Z_STREAM_END)
+    if ( rc != Z_STREAM_END )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "%s: inflate failed (rc=%d)\n", __FUNCTION__, rc);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "%s: inflate failed (rc=%d)\n", __FUNCTION__, rc);
+        return -1;
     }
 
     xc_dom_printf("%s: unzip ok, 0x%zx -> 0x%zx\n",
-		  __FUNCTION__, srclen, dstlen);
+                  __FUNCTION__, srclen, dstlen);
     return 0;
 }
 
@@ -261,15 +262,15 @@ int xc_dom_try_gunzip(struct xc_dom_image *dom, void **blob, size_t * size)
     size_t unziplen;
 
     unziplen = xc_dom_check_gzip(*blob, *size);
-    if (0 == unziplen)
-	return 0;
+    if ( unziplen == 0 )
+        return 0;
 
     unzip = xc_dom_malloc(dom, unziplen);
-    if (NULL == unzip)
-	return -1;
+    if ( unzip == NULL )
+        return -1;
 
-    if (-1 == xc_dom_do_gunzip(*blob, *size, unzip, unziplen))
-	return -1;
+    if ( xc_dom_do_gunzip(*blob, *size, unzip, unziplen) == -1 )
+        return -1;
 
     *blob = unzip;
     *size = unziplen;
@@ -280,92 +281,94 @@ int xc_dom_try_gunzip(struct xc_dom_image *dom, void **blob, size_t * size)
 /* domain memory                                                            */
 
 void *xc_dom_pfn_to_ptr(struct xc_dom_image *dom, xen_pfn_t pfn,
-			xen_pfn_t count)
+                        xen_pfn_t count)
 {
     struct xc_dom_phys *phys;
     unsigned int page_shift = XC_DOM_PAGE_SHIFT(dom);
     char *mode = "unset";
 
-    if (pfn > dom->total_pages)
+    if ( pfn > dom->total_pages )
     {
-	xc_dom_printf("%s: pfn out of range (0x%" PRIpfn " > 0x%" PRIpfn ")\n",
-		      __FUNCTION__, pfn, dom->total_pages);
-	return NULL;
+        xc_dom_printf("%s: pfn out of range (0x%" PRIpfn " > 0x%" PRIpfn ")\n",
+                      __FUNCTION__, pfn, dom->total_pages);
+        return NULL;
     }
 
     /* already allocated? */
-    for (phys = dom->phys_pages; NULL != phys; phys = phys->next)
+    for ( phys = dom->phys_pages; phys != NULL; phys = phys->next )
     {
-	if (pfn >= phys->first + phys->count)
-	    continue;
-	if (count)
-	{
-	    /* size given: must be completely within the already allocated block */
-	    if (pfn + count <= phys->first)
-		continue;
-	    if (pfn < phys->first || pfn + count > phys->first + phys->count)
-	    {
-		xc_dom_printf("%s: request overlaps allocated block"
-			      " (req 0x%" PRIpfn "+0x%" PRIpfn ","
-			      " blk 0x%" PRIpfn "+0x%" PRIpfn ")\n",
-			      __FUNCTION__, pfn, count, phys->first,
-			      phys->count);
-		return NULL;
-	    }
-	}
-	else
-	{
-	    /* no size given: block must be allocated already,
-	       just hand out a pointer to it */
-	    if (pfn < phys->first)
-		continue;
-	}
-	return phys->ptr + ((pfn - phys->first) << page_shift);
+        if ( pfn >= (phys->first + phys->count) )
+            continue;
+        if ( count )
+        {
+            /* size given: must be completely within the already allocated block */
+            if ( (pfn + count) <= phys->first )
+                continue;
+            if ( (pfn < phys->first) ||
+                 ((pfn + count) > (phys->first + phys->count)) )
+            {
+                xc_dom_printf("%s: request overlaps allocated block"
+                              " (req 0x%" PRIpfn "+0x%" PRIpfn ","
+                              " blk 0x%" PRIpfn "+0x%" PRIpfn ")\n",
+                              __FUNCTION__, pfn, count, phys->first,
+                              phys->count);
+                return NULL;
+            }
+        }
+        else
+        {
+            /* no size given: block must be allocated already,
+               just hand out a pointer to it */
+            if ( pfn < phys->first )
+                continue;
+        }
+        return phys->ptr + ((pfn - phys->first) << page_shift);
     }
 
     /* allocating is allowed with size specified only */
-    if (0 == count)
+    if ( count == 0 )
     {
-	xc_dom_printf("%s: no block found, no size given,"
-		      " can't malloc (pfn 0x%" PRIpfn ")\n", __FUNCTION__, pfn);
-	return NULL;
+        xc_dom_printf("%s: no block found, no size given,"
+                      " can't malloc (pfn 0x%" PRIpfn ")\n",
+                      __FUNCTION__, pfn);
+        return NULL;
     }
 
     /* not found, no overlap => allocate */
     phys = xc_dom_malloc(dom, sizeof(*phys));
-    if (NULL == phys)
-	return NULL;
+    if ( phys == NULL )
+        return NULL;
     memset(phys, 0, sizeof(*phys));
     phys->first = pfn;
     phys->count = count;
 
-    if (dom->guest_domid)
+    if ( dom->guest_domid )
     {
-	mode = "domU mapping";
-	phys->ptr = xc_dom_boot_domU_map(dom, phys->first, phys->count);
-	if (NULL == phys->ptr)
-	    return NULL;
-	dom->alloc_domU_map += phys->count << page_shift;
+        mode = "domU mapping";
+        phys->ptr = xc_dom_boot_domU_map(dom, phys->first, phys->count);
+        if ( phys->ptr == NULL )
+            return NULL;
+        dom->alloc_domU_map += phys->count << page_shift;
     }
     else
     {
-	mode = "anonymous memory";
-	phys->ptr = mmap(NULL, phys->count << page_shift,
-			 PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
-			 -1, 0);
-	if (MAP_FAILED == phys->ptr)
-	{
-	    xc_dom_panic(XC_OUT_OF_MEMORY,
-			 "%s: oom: can't allocate 0x%" PRIpfn " pages\n",
-			 __FUNCTION__, count);
-	    return NULL;
-	}
-	dom->alloc_mem_map += phys->count << page_shift;
+        mode = "anonymous memory";
+        phys->ptr = mmap(NULL, phys->count << page_shift,
+                         PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
+                         -1, 0);
+        if ( phys->ptr == MAP_FAILED )
+        {
+            xc_dom_panic(XC_OUT_OF_MEMORY,
+                         "%s: oom: can't allocate 0x%" PRIpfn " pages\n",
+                         __FUNCTION__, count);
+            return NULL;
+        }
+        dom->alloc_mem_map += phys->count << page_shift;
     }
 
 #if 1
     xc_dom_printf("%s: %s: pfn 0x%" PRIpfn "+0x%" PRIpfn " at %p\n",
-		  __FUNCTION__, mode, phys->first, phys->count, phys->ptr);
+                  __FUNCTION__, mode, phys->first, phys->count, phys->ptr);
 #endif
     phys->next = dom->phys_pages;
     dom->phys_pages = phys;
@@ -373,29 +376,29 @@ void *xc_dom_pfn_to_ptr(struct xc_dom_image *dom, xen_pfn_t pfn,
 }
 
 int xc_dom_alloc_segment(struct xc_dom_image *dom,
-			 struct xc_dom_seg *seg, char *name,
-			 xen_vaddr_t start, xen_vaddr_t size)
+                         struct xc_dom_seg *seg, char *name,
+                         xen_vaddr_t start, xen_vaddr_t size)
 {
     unsigned int page_size = XC_DOM_PAGE_SIZE(dom);
     xen_pfn_t pages = (size + page_size - 1) / page_size;
     void *ptr;
 
-    if (0 == start)
-	start = dom->virt_alloc_end;
+    if ( start == 0 )
+        start = dom->virt_alloc_end;
 
-    if (start & (page_size - 1))
+    if ( start & (page_size - 1) )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "%s: segment start isn't page aligned (0x%" PRIx64 ")\n",
-		     __FUNCTION__, start);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "%s: segment start isn't page aligned (0x%" PRIx64 ")\n",
+                     __FUNCTION__, start);
+        return -1;
     }
-    if (start < dom->virt_alloc_end)
+    if ( start < dom->virt_alloc_end )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "%s: segment start too low (0x%" PRIx64 " < 0x%" PRIx64
-		     ")\n", __FUNCTION__, start, dom->virt_alloc_end);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "%s: segment start too low (0x%" PRIx64 " < 0x%" PRIx64
+                     ")\n", __FUNCTION__, start, dom->virt_alloc_end);
+        return -1;
     }
 
     seg->vstart = start;
@@ -404,13 +407,13 @@ int xc_dom_alloc_segment(struct xc_dom_image *dom,
     dom->virt_alloc_end = seg->vend;
 
     xc_dom_printf("%-20s:   %-12s : 0x%" PRIx64 " -> 0x%" PRIx64
-		  "  (pfn 0x%" PRIpfn " + 0x%" PRIpfn " pages)\n",
-		  __FUNCTION__, name, seg->vstart, seg->vend, seg->pfn, pages);
+                  "  (pfn 0x%" PRIpfn " + 0x%" PRIpfn " pages)\n",
+                  __FUNCTION__, name, seg->vstart, seg->vend, seg->pfn, pages);
 
     /* map and clear pages */
     ptr = xc_dom_seg_to_ptr(dom, seg);
-    if (NULL == ptr)
-	return -1;
+    if ( ptr == NULL )
+        return -1;
     memset(ptr, 0, pages * page_size);
 
     return 0;
@@ -427,7 +430,7 @@ int xc_dom_alloc_page(struct xc_dom_image *dom, char *name)
     pfn = (start - dom->parms.virt_base) / page_size;
 
     xc_dom_printf("%-20s:   %-12s : 0x%" PRIx64 " (pfn 0x%" PRIpfn ")\n",
-		  __FUNCTION__, name, start, pfn);
+                  __FUNCTION__, name, start, pfn);
     return pfn;
 }
 
@@ -436,30 +439,30 @@ void xc_dom_unmap_one(struct xc_dom_image *dom, xen_pfn_t pfn)
     unsigned int page_shift = XC_DOM_PAGE_SHIFT(dom);
     struct xc_dom_phys *phys, *prev = NULL;
 
-    for (phys = dom->phys_pages; NULL != phys; phys = phys->next)
+    for ( phys = dom->phys_pages; phys != NULL; phys = phys->next )
     {
-	if (pfn >= phys->first && pfn < phys->first + phys->count)
-	    break;
-	prev = phys;
+        if ( (pfn >= phys->first) && (pfn < (phys->first + phys->count)) )
+            break;
+        prev = phys;
     }
-    if (!phys)
+    if ( !phys )
     {
-	xc_dom_printf("%s: Huh? no mapping with pfn 0x%" PRIpfn "\n",
-		      __FUNCTION__, pfn);
-	return;
+        xc_dom_printf("%s: Huh? no mapping with pfn 0x%" PRIpfn "\n",
+                      __FUNCTION__, pfn);
+        return;
     }
 
     munmap(phys->ptr, phys->count << page_shift);
-    if (prev)
-	prev->next = phys->next;
+    if ( prev )
+        prev->next = phys->next;
     else
-	dom->phys_pages = phys->next;
+        dom->phys_pages = phys->next;
 }
 
 void xc_dom_unmap_all(struct xc_dom_image *dom)
 {
-    while (dom->phys_pages)
-	xc_dom_unmap_one(dom, dom->phys_pages->first);
+    while ( dom->phys_pages )
+        xc_dom_unmap_one(dom, dom->phys_pages->first);
 }
 
 /* ------------------------------------------------------------------------ */
@@ -478,16 +481,16 @@ static struct xc_dom_loader *xc_dom_find_loader(struct xc_dom_image *dom)
 {
     struct xc_dom_loader *loader = first_loader;
 
-    while (NULL != loader)
+    while ( loader != NULL )
     {
-	xc_dom_printf("%s: trying %s loader ... ", __FUNCTION__, loader->name);
-	if (0 == loader->probe(dom))
-	{
-	    xc_dom_printf("OK\n");
-	    return loader;
-	}
-	xc_dom_printf("failed\n");
-	loader = loader->next;
+        xc_dom_printf("%s: trying %s loader ... ", __FUNCTION__, loader->name);
+        if ( loader->probe(dom) == 0 )
+        {
+            xc_dom_printf("OK\n");
+            return loader;
+        }
+        xc_dom_printf("failed\n");
+        loader = loader->next;
     }
     xc_dom_panic(XC_INVALID_KERNEL, "%s: no loader found\n", __FUNCTION__);
     return NULL;
@@ -503,14 +506,14 @@ static struct xc_dom_arch *xc_dom_find_arch_hooks(char *guest_type)
 {
     struct xc_dom_arch *hooks = first_hook;
 
-    while (NULL != hooks)
+    while (  hooks != NULL )
     {
-	if (0 == strcmp(hooks->guest_type, guest_type))
-	    return hooks;
-	hooks = hooks->next;
+        if ( !strcmp(hooks->guest_type, guest_type))
+            return hooks;
+        hooks = hooks->next;
     }
     xc_dom_panic(XC_INVALID_KERNEL,
-		 "%s: not found (type %s)\n", __FUNCTION__, guest_type);
+                 "%s: not found (type %s)\n", __FUNCTION__, guest_type);
     return NULL;
 }
 
@@ -520,8 +523,8 @@ static struct xc_dom_arch *xc_dom_find_arch_hooks(char *guest_type)
 void xc_dom_release(struct xc_dom_image *dom)
 {
     xc_dom_printf("%s: called\n", __FUNCTION__);
-    if (dom->phys_pages)
-	xc_dom_unmap_all(dom);
+    if ( dom->phys_pages )
+        xc_dom_unmap_all(dom);
     xc_dom_free_all(dom);
     free(dom);
 }
@@ -531,16 +534,16 @@ struct xc_dom_image *xc_dom_allocate(const char *cmdline, const char *features)
     struct xc_dom_image *dom;
 
     xc_dom_printf("%s: cmdline=\"%s\", features=\"%s\"\n",
-		  __FUNCTION__, cmdline, features);
+                  __FUNCTION__, cmdline, features);
     dom = malloc(sizeof(*dom));
-    if (!dom)
-	goto err;
+    if ( !dom )
+        goto err;
 
     memset(dom, 0, sizeof(*dom));
-    if (cmdline)
-	dom->cmdline = xc_dom_strdup(dom, cmdline);
-    if (features)
-	elf_xen_parse_features(features, dom->f_requested, NULL);
+    if ( cmdline )
+        dom->cmdline = xc_dom_strdup(dom, cmdline);
+    if ( features )
+        elf_xen_parse_features(features, dom->f_requested, NULL);
 
     dom->parms.virt_base = UNSET_ADDR;
     dom->parms.virt_entry = UNSET_ADDR;
@@ -551,9 +554,9 @@ struct xc_dom_image *xc_dom_allocate(const char *cmdline, const char *features)
     dom->alloc_malloc += sizeof(*dom);
     return dom;
 
-  err:
-    if (dom)
-	xc_dom_release(dom);
+ err:
+    if ( dom )
+        xc_dom_release(dom);
     return NULL;
 }
 
@@ -561,8 +564,8 @@ int xc_dom_kernel_file(struct xc_dom_image *dom, const char *filename)
 {
     xc_dom_printf("%s: filename=\"%s\"\n", __FUNCTION__, filename);
     dom->kernel_blob = xc_dom_malloc_filemap(dom, filename, &dom->kernel_size);
-    if (NULL == dom->kernel_blob)
-	return -1;
+    if ( dom->kernel_blob == NULL )
+        return -1;
     return xc_dom_try_gunzip(dom, &dom->kernel_blob, &dom->kernel_size);
 }
 
@@ -570,9 +573,9 @@ int xc_dom_ramdisk_file(struct xc_dom_image *dom, const char *filename)
 {
     xc_dom_printf("%s: filename=\"%s\"\n", __FUNCTION__, filename);
     dom->ramdisk_blob =
-	xc_dom_malloc_filemap(dom, filename, &dom->ramdisk_size);
-    if (NULL == dom->ramdisk_blob)
-	return -1;
+        xc_dom_malloc_filemap(dom, filename, &dom->ramdisk_size);
+    if ( dom->ramdisk_blob == NULL )
+        return -1;
 //    return xc_dom_try_gunzip(dom, &dom->ramdisk_blob, &dom->ramdisk_size);
     return 0;
 }
@@ -586,7 +589,7 @@ int xc_dom_kernel_mem(struct xc_dom_image *dom, const void *mem, size_t memsize)
 }
 
 int xc_dom_ramdisk_mem(struct xc_dom_image *dom, const void *mem,
-		       size_t memsize)
+                       size_t memsize)
 {
     xc_dom_printf("%s: called\n", __FUNCTION__);
     dom->ramdisk_blob = (void *)mem;
@@ -603,32 +606,33 @@ int xc_dom_parse_image(struct xc_dom_image *dom)
 
     /* parse kernel image */
     dom->kernel_loader = xc_dom_find_loader(dom);
-    if (NULL == dom->kernel_loader)
-	goto err;
-    if (0 != dom->kernel_loader->parser(dom))
-	goto err;
-    if (NULL == dom->guest_type)
+    if ( dom->kernel_loader == NULL )
+        goto err;
+    if ( dom->kernel_loader->parser(dom) != 0 )
+        goto err;
+    if ( dom->guest_type == NULL )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "%s: guest_type not set\n", __FUNCTION__);
-	goto err;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "%s: guest_type not set\n", __FUNCTION__);
+        goto err;
     }
 
     /* check features */
-    for (i = 0; i < XENFEAT_NR_SUBMAPS; i++)
+    for ( i = 0; i < XENFEAT_NR_SUBMAPS; i++ )
     {
-	dom->f_active[i] |= dom->f_requested[i];	/* cmd line */
-	dom->f_active[i] |= dom->parms.f_required[i];	/* kernel   */
-	if ((dom->f_active[i] & dom->parms.f_supported[i]) != dom->f_active[i])
-	{
-	    xc_dom_panic(XC_INVALID_PARAM,
-			 "%s: unsupported feature requested\n", __FUNCTION__);
-	    goto err;
-	}
+        dom->f_active[i] |= dom->f_requested[i]; /* cmd line */
+        dom->f_active[i] |= dom->parms.f_required[i]; /* kernel   */
+        if ( (dom->f_active[i] & dom->parms.f_supported[i]) !=
+             dom->f_active[i] )
+        {
+            xc_dom_panic(XC_INVALID_PARAM,
+                         "%s: unsupported feature requested\n", __FUNCTION__);
+            goto err;
+        }
     }
     return 0;
 
-  err:
+ err:
     return -1;
 }
 
@@ -638,27 +642,27 @@ int xc_dom_mem_init(struct xc_dom_image *dom, unsigned int mem_mb)
     xen_pfn_t nr_pages, pfn;
 
     dom->arch_hooks = xc_dom_find_arch_hooks(dom->guest_type);
-    if (NULL == dom->arch_hooks)
+    if ( dom->arch_hooks == NULL )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR, "%s: arch hooks not set\n",
-		     __FUNCTION__);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR, "%s: arch hooks not set\n",
+                     __FUNCTION__);
+        return -1;
     }
 
     page_shift = XC_DOM_PAGE_SHIFT(dom);
     nr_pages = mem_mb << (20 - page_shift);
 
     xc_dom_printf("%s: mem %d MB, pages 0x%" PRIpfn " pages, %dk each\n",
-		  __FUNCTION__, mem_mb, nr_pages, 1 << (page_shift-10));
+                  __FUNCTION__, mem_mb, nr_pages, 1 << (page_shift-10));
     dom->total_pages = nr_pages;
 
     xc_dom_printf("%s: 0x%" PRIpfn " pages\n",
-		  __FUNCTION__, dom->total_pages);
+                  __FUNCTION__, dom->total_pages);
 
     /* setup initial p2m */
     dom->p2m_host = xc_dom_malloc(dom, sizeof(xen_pfn_t) * dom->total_pages);
-    for (pfn = 0; pfn < dom->total_pages; pfn++)
-	dom->p2m_host[pfn] = pfn;
+    for ( pfn = 0; pfn < dom->total_pages; pfn++ )
+        dom->p2m_host[pfn] = pfn;
     return 0;
 }
 
@@ -668,36 +672,36 @@ int xc_dom_update_guest_p2m(struct xc_dom_image *dom)
     uint64_t *p2m_64;
     xen_pfn_t i;
 
-    if (!dom->p2m_guest)
-	return 0;
+    if ( !dom->p2m_guest )
+        return 0;
 
-    switch (dom->arch_hooks->sizeof_pfn)
+    switch ( dom->arch_hooks->sizeof_pfn )
     {
     case 4:
-	xc_dom_printf("%s: dst 32bit, pages 0x%" PRIpfn " \n",
-		      __FUNCTION__, dom->total_pages);
-	p2m_32 = dom->p2m_guest;
-	for (i = 0; i < dom->total_pages; i++)
-	    if (INVALID_P2M_ENTRY != dom->p2m_host[i])
-		p2m_32[i] = dom->p2m_host[i];
-	    else
-		p2m_32[i] = (uint32_t) - 1;
-	break;
+        xc_dom_printf("%s: dst 32bit, pages 0x%" PRIpfn " \n",
+                      __FUNCTION__, dom->total_pages);
+        p2m_32 = dom->p2m_guest;
+        for ( i = 0; i < dom->total_pages; i++ )
+            if ( dom->p2m_host[i] != INVALID_P2M_ENTRY )
+                p2m_32[i] = dom->p2m_host[i];
+            else
+                p2m_32[i] = (uint32_t) - 1;
+        break;
     case 8:
-	xc_dom_printf("%s: dst 64bit, pages 0x%" PRIpfn " \n",
-		      __FUNCTION__, dom->total_pages);
-	p2m_64 = dom->p2m_guest;
-	for (i = 0; i < dom->total_pages; i++)
-	    if (INVALID_P2M_ENTRY != dom->p2m_host[i])
-		p2m_64[i] = dom->p2m_host[i];
-	    else
-		p2m_64[i] = (uint64_t) - 1;
-	break;
+        xc_dom_printf("%s: dst 64bit, pages 0x%" PRIpfn " \n",
+                      __FUNCTION__, dom->total_pages);
+        p2m_64 = dom->p2m_guest;
+        for ( i = 0; i < dom->total_pages; i++ )
+            if ( dom->p2m_host[i] != INVALID_P2M_ENTRY )
+                p2m_64[i] = dom->p2m_host[i];
+            else
+                p2m_64[i] = (uint64_t) - 1;
+        break;
     default:
-	xc_dom_panic(XC_INTERNAL_ERROR,
-		     "sizeof_pfn is invalid (is %d, can be 4 or 8)",
-		     dom->arch_hooks->sizeof_pfn);
-	return -1;
+        xc_dom_panic(XC_INTERNAL_ERROR,
+                     "sizeof_pfn is invalid (is %d, can be 4 or 8)",
+                     dom->arch_hooks->sizeof_pfn);
+        return -1;
     }
     return 0;
 }
@@ -709,11 +713,11 @@ int xc_dom_build_image(struct xc_dom_image *dom)
     xc_dom_printf("%s: called\n", __FUNCTION__);
 
     /* check for arch hooks */
-    if (NULL == dom->arch_hooks)
+    if ( dom->arch_hooks == NULL )
     {
-	xc_dom_panic(XC_INTERNAL_ERROR, "%s: arch hooks not set\n",
-		     __FUNCTION__);
-	goto err;
+        xc_dom_panic(XC_INTERNAL_ERROR, "%s: arch hooks not set\n",
+                     __FUNCTION__);
+        goto err;
     }
     page_size = XC_DOM_PAGE_SIZE(dom);
 
@@ -721,56 +725,65 @@ int xc_dom_build_image(struct xc_dom_image *dom)
     dom->parms.virt_base &= ~(((uint64_t)1<<22)-1);
 
     /* load kernel */
-    if (0 != xc_dom_alloc_segment(dom, &dom->kernel_seg, "kernel",
-				  dom->kernel_seg.vstart,
-				  dom->kernel_seg.vend -
-				  dom->kernel_seg.vstart))
-	goto err;
-    if (0 != dom->kernel_loader->loader(dom))
-	goto err;
+    if ( xc_dom_alloc_segment(dom, &dom->kernel_seg, "kernel",
+                              dom->kernel_seg.vstart,
+                              dom->kernel_seg.vend -
+                              dom->kernel_seg.vstart) != 0 )
+        goto err;
+    if ( dom->kernel_loader->loader(dom) != 0 )
+        goto err;
 
     /* load ramdisk */
-    if (dom->ramdisk_blob)
+    if ( dom->ramdisk_blob )
     {
-	size_t unziplen, ramdisklen;
-	void *ramdiskmap;
-
-	unziplen = xc_dom_check_gzip(dom->ramdisk_blob, dom->ramdisk_size);
-	ramdisklen = unziplen ? unziplen : dom->ramdisk_size;
-	if (0 != xc_dom_alloc_segment(dom, &dom->ramdisk_seg, "ramdisk", 0,
-				      ramdisklen))
-	    goto err;
-	ramdiskmap = xc_dom_seg_to_ptr(dom, &dom->ramdisk_seg);
-	if (unziplen)
-	{
-	    if (-1 == xc_dom_do_gunzip(dom->ramdisk_blob, dom->ramdisk_size,
-				       ramdiskmap, ramdisklen))
-		goto err;
-	}
-	else
-	    memcpy(ramdiskmap, dom->ramdisk_blob, dom->ramdisk_size);
+        size_t unziplen, ramdisklen;
+        void *ramdiskmap;
+
+        unziplen = xc_dom_check_gzip(dom->ramdisk_blob, dom->ramdisk_size);
+        ramdisklen = unziplen ? unziplen : dom->ramdisk_size;
+        if ( xc_dom_alloc_segment(dom, &dom->ramdisk_seg, "ramdisk", 0,
+                                  ramdisklen) != 0 )
+            goto err;
+        ramdiskmap = xc_dom_seg_to_ptr(dom, &dom->ramdisk_seg);
+        if ( unziplen )
+        {
+            if ( xc_dom_do_gunzip(dom->ramdisk_blob, dom->ramdisk_size,
+                                  ramdiskmap, ramdisklen) == -1 )
+                goto err;
+        }
+        else
+            memcpy(ramdiskmap, dom->ramdisk_blob, dom->ramdisk_size);
     }
 
     /* allocate other pages */
-    if (0 != dom->arch_hooks->alloc_magic_pages(dom))
-	goto err;
-    if (dom->arch_hooks->count_pgtables)
+    if ( dom->arch_hooks->alloc_magic_pages(dom) != 0 )
+        goto err;
+    if ( dom->arch_hooks->count_pgtables )
     {
-	dom->arch_hooks->count_pgtables(dom);
-	if (dom->pgtables > 0)
-	    if (0 !=
-		xc_dom_alloc_segment(dom, &dom->pgtables_seg, "page tables", 0,
-				     dom->pgtables * page_size))
-		goto err;
+        dom->arch_hooks->count_pgtables(dom);
+        if ( (dom->pgtables > 0) &&
+             (xc_dom_alloc_segment(dom, &dom->pgtables_seg, "page tables", 0,
+                                   dom->pgtables * page_size) != 0) )
+                goto err;
     }
-    if (dom->alloc_bootstack)
-	dom->bootstack_pfn = xc_dom_alloc_page(dom, "boot stack");
+    if ( dom->alloc_bootstack )
+        dom->bootstack_pfn = xc_dom_alloc_page(dom, "boot stack");
     xc_dom_printf("%-20s: virt_alloc_end : 0x%" PRIx64 "\n",
-		  __FUNCTION__, dom->virt_alloc_end);
+                  __FUNCTION__, dom->virt_alloc_end);
     xc_dom_printf("%-20s: virt_pgtab_end : 0x%" PRIx64 "\n",
-		  __FUNCTION__, dom->virt_pgtab_end);
+                  __FUNCTION__, dom->virt_pgtab_end);
     return 0;
 
-  err:
+ err:
     return -1;
 }
+
+/*
+ * Local variables:
+ * mode: C
+ * c-set-style: "BSD"
+ * c-basic-offset: 4
+ * tab-width: 4
+ * indent-tabs-mode: nil
+ * End:
+ */