[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

[Xen-changelog] [xen-unstable] lockprof: Fix x86_32 build and clean up coding style



# HG changeset patch
# User Keir Fraser <keir.fraser@xxxxxxxxxx>
# Date 1255591773 -3600
# Node ID 9e24f7f9d7a8c59747c4d7cd75215958d231f0b9
# Parent  cc8044c5da4c99149bc8aca68de299db8aa56b45
lockprof: Fix x86_32 build and clean up coding style

Signed-off-by: Keir Fraser <keir.fraser@xxxxxxxxxx>
---
 tools/misc/xenlockprof.c   |   35 ++++++++-------
 xen/common/spinlock.c      |  103 ++++++++++++++++++++-------------------------
 xen/include/xen/spinlock.h |    8 +--
 3 files changed, 69 insertions(+), 77 deletions(-)

diff -r cc8044c5da4c -r 9e24f7f9d7a8 tools/misc/xenlockprof.c
--- a/tools/misc/xenlockprof.c  Thu Oct 15 08:16:42 2009 +0100
+++ b/tools/misc/xenlockprof.c  Thu Oct 15 08:29:33 2009 +0100
@@ -16,6 +16,7 @@
 #include <sys/mman.h>
 #include <errno.h>
 #include <string.h>
+#include <inttypes.h>
 
 static int lock_pages(void *addr, size_t len)
 {
@@ -42,7 +43,7 @@ int main(int argc, char *argv[])
     char               name[60];
     xc_lockprof_data_t *data;
 
-    if ((argc > 2) || ((argc == 2) && (strcmp(argv[1], "-r") != 0)))
+    if ( (argc > 2) || ((argc == 2) && (strcmp(argv[1], "-r") != 0)) )
     {
         printf("%s: [-r]\n", argv[0]);
         printf("no args: print lock profile data\n");
@@ -50,28 +51,28 @@ int main(int argc, char *argv[])
         return 1;
     }
 
-    if ((xc_handle = xc_interface_open()) == -1)
+    if ( (xc_handle = xc_interface_open()) == -1 )
     {
         fprintf(stderr, "Error opening xc interface: %d (%s)\n",
                 errno, strerror(errno));
         return 1;
     }
 
-    if (argc > 1)
+    if ( argc > 1 )
     {
-        if (xc_lockprof_control(xc_handle, XEN_SYSCTL_LOCKPROF_reset, NULL,
-                                NULL, NULL) != 0)
+        if ( xc_lockprof_control(xc_handle, XEN_SYSCTL_LOCKPROF_reset, NULL,
+                                 NULL, NULL) != 0 )
         {
             fprintf(stderr, "Error reseting profile data: %d (%s)\n",
                     errno, strerror(errno));
             return 1;
         }
-        return 1;
+        return 0;
     }
 
     n = 0;
-    if (xc_lockprof_control(xc_handle, XEN_SYSCTL_LOCKPROF_query, &n,
-                            NULL, NULL) != 0)
+    if ( xc_lockprof_control(xc_handle, XEN_SYSCTL_LOCKPROF_query, &n,
+                             NULL, NULL) != 0 )
     {
         fprintf(stderr, "Error getting number of profile records: %d (%s)\n",
                 errno, strerror(errno));
@@ -80,7 +81,7 @@ int main(int argc, char *argv[])
 
     n += 32;    /* just to be sure */
     data = malloc(sizeof(*data) * n);
-    if ((data == NULL) || (lock_pages(data, sizeof(*data) * n) != 0))
+    if ( (data == NULL) || (lock_pages(data, sizeof(*data) * n) != 0) )
     {
         fprintf(stderr, "Could not alloc or lock buffers: %d (%s)\n",
                 errno, strerror(errno));
@@ -89,7 +90,7 @@ int main(int argc, char *argv[])
 
     i = n;
     if ( xc_lockprof_control(xc_handle, XEN_SYSCTL_LOCKPROF_query, &i,
-                             &time, data) != 0)
+                             &time, data) != 0 )
     {
         fprintf(stderr, "Error getting profile records: %d (%s)\n",
                 errno, strerror(errno));
@@ -98,16 +99,17 @@ int main(int argc, char *argv[])
 
     unlock_pages(data, sizeof(*data) * n);
 
-    if (i > n)
+    if ( i > n )
     {
         printf("data incomplete, %d records are missing!\n\n", i - n);
         i = n;
     }
+
     sl = 0;
     sb = 0;
-    for (j = 0; j < i; j++)
+    for ( j = 0; j < i; j++ )
     {
-        switch (data[j].type)
+        switch ( data[j].type )
         {
         case LOCKPROF_TYPE_GLOBAL:
             sprintf(name, "global lock %s", data[j].name);
@@ -117,15 +119,16 @@ int main(int argc, char *argv[])
             break;
         default:
             sprintf(name, "unknown type(%d) %d lock %s", data[j].type,
-                data[j].idx, data[j].name);
+                    data[j].idx, data[j].name);
             break;
         }
         l = (double)(data[j].lock_time) / 1E+09;
         b = (double)(data[j].block_time) / 1E+09;
         sl += l;
         sb += b;
-        printf("%-50s: lock:%12ld(%20.9fs), block:%12ld(%20.9fs)\n",
-            name, data[j].lock_cnt, l, data[j].block_cnt, b);
+        printf("%-50s: lock:%12"PRId64"(%20.9fs), "
+               "block:%12"PRId64"(%20.9fs)\n",
+               name, data[j].lock_cnt, l, data[j].block_cnt, b);
     }
     l = (double)time / 1E+09;
     printf("total profiling time: %20.9fs\n", l);
diff -r cc8044c5da4c -r 9e24f7f9d7a8 xen/common/spinlock.c
--- a/xen/common/spinlock.c     Thu Oct 15 08:16:42 2009 +0100
+++ b/xen/common/spinlock.c     Thu Oct 15 08:29:33 2009 +0100
@@ -314,54 +314,48 @@ int _rw_is_write_locked(rwlock_t *lock)
 }
 
 #ifdef LOCK_PROFILE
+
 struct lock_profile_anc {
     struct lock_profile_qhead *head_q;   /* first head of this type */
     char                      *name;     /* descriptive string for print */
 };
 
-typedef void lock_profile_subfunc(struct lock_profile *, int32_t, int32_t,
-                                  void *);
+typedef void lock_profile_subfunc(
+    struct lock_profile *, int32_t, int32_t, void *);
 
 extern struct lock_profile *__lock_profile_start;
 extern struct lock_profile *__lock_profile_end;
 
-static s_time_t lock_profile_start = 0;
+static s_time_t lock_profile_start;
 static struct lock_profile_anc lock_profile_ancs[LOCKPROF_TYPE_N];
 static struct lock_profile_qhead lock_profile_glb_q;
 static spinlock_t lock_profile_lock = SPIN_LOCK_UNLOCKED;
 
 static void spinlock_profile_iterate(lock_profile_subfunc *sub, void *par)
 {
-    int  i;
+    int i;
     struct lock_profile_qhead *hq;
     struct lock_profile *eq;
 
     spin_lock(&lock_profile_lock);
-    for (i = 0; i < LOCKPROF_TYPE_N; i++)
-    {
-        for (hq = lock_profile_ancs[i].head_q; hq; hq = hq->head_q)
-        {
-            for (eq = hq->elem_q; eq; eq = eq->next)
-            {
+    for ( i = 0; i < LOCKPROF_TYPE_N; i++ )
+        for ( hq = lock_profile_ancs[i].head_q; hq; hq = hq->head_q )
+            for ( eq = hq->elem_q; eq; eq = eq->next )
                 sub(eq, i, hq->idx, par);
-            }
-        }
-    }
     spin_unlock(&lock_profile_lock);
-    return;
 }
 
 static void spinlock_profile_print_elem(struct lock_profile *data,
     int32_t type, int32_t idx, void *par)
 {
-    if (type == LOCKPROF_TYPE_GLOBAL)
+    if ( type == LOCKPROF_TYPE_GLOBAL )
         printk("%s %s:\n", lock_profile_ancs[idx].name, data->name);
     else
         printk("%s %d %s:\n", lock_profile_ancs[idx].name, idx, data->name);
-    printk("  lock:%12ld(%08X:%08X), block:%12ld(%08X:%08X)\n",
-        data->lock_cnt, (u32)(data->time_hold >> 32), (u32)data->time_hold,
-        data->block_cnt, (u32)(data->time_block >> 32), (u32)data->time_block);
-    return;
+    printk("  lock:%12"PRId64"(%08X:%08X), block:%12"PRId64"(%08X:%08X)\n",
+           data->lock_cnt, (u32)(data->time_hold >> 32), (u32)data->time_hold,
+           data->block_cnt, (u32)(data->time_block >> 32),
+           (u32)data->time_block);
 }
 
 void spinlock_profile_printall(unsigned char key)
@@ -374,7 +368,6 @@ void spinlock_profile_printall(unsigned 
         "total = %08X:%08X)\n", (u32)(now>>32), (u32)now,
         (u32)(diff>>32), (u32)diff);
     spinlock_profile_iterate(spinlock_profile_print_elem, NULL);
-    return;
 }
 
 static void spinlock_profile_reset_elem(struct lock_profile *data,
@@ -384,7 +377,6 @@ static void spinlock_profile_reset_elem(
     data->block_cnt = 0;
     data->time_hold = 0;
     data->time_block = 0;
-    return;
 }
 
 void spinlock_profile_reset(unsigned char key)
@@ -396,7 +388,6 @@ void spinlock_profile_reset(unsigned cha
             (u32)(now>>32), (u32)now);
     lock_profile_start = now;
     spinlock_profile_iterate(spinlock_profile_reset_elem, NULL);
-    return;
 }
 
 typedef struct {
@@ -407,14 +398,13 @@ static void spinlock_profile_ucopy_elem(
 static void spinlock_profile_ucopy_elem(struct lock_profile *data,
     int32_t type, int32_t idx, void *par)
 {
-    spinlock_profile_ucopy_t *p;
+    spinlock_profile_ucopy_t *p = par;
     xen_sysctl_lockprof_data_t elem;
 
-    p = (spinlock_profile_ucopy_t *)par;
-    if (p->rc)
+    if ( p->rc )
         return;
 
-    if (p->pc->nr_elem < p->pc->max_elem)
+    if ( p->pc->nr_elem < p->pc->max_elem )
     {
         safe_strcpy(elem.name, data->name);
         elem.type = type;
@@ -423,46 +413,43 @@ static void spinlock_profile_ucopy_elem(
         elem.block_cnt = data->block_cnt;
         elem.lock_time = data->time_hold;
         elem.block_time = data->time_block;
-        if (copy_to_guest_offset(p->pc->data, p->pc->nr_elem, &elem, 1))
-        {
+        if ( copy_to_guest_offset(p->pc->data, p->pc->nr_elem, &elem, 1) )
             p->rc = -EFAULT;
-            return;
-        }
-    }
-    p->pc->nr_elem++;
-    
-    return;
+    }
+
+    if ( !p->rc )
+        p->pc->nr_elem++;
 }
 
 /* Dom0 control of lock profiling */
 int spinlock_profile_control(xen_sysctl_lockprof_op_t *pc)
 {
-    int rc;
+    int rc = 0;
     spinlock_profile_ucopy_t par;
 
-    rc = 0;
-    switch (pc->cmd)
+    switch ( pc->cmd )
     {
     case XEN_SYSCTL_LOCKPROF_reset:
         spinlock_profile_reset('\0');
         break;
     case XEN_SYSCTL_LOCKPROF_query:
-       pc->nr_elem = 0;
-       par.rc = 0;
-       par.pc = pc;
+        pc->nr_elem = 0;
+        par.rc = 0;
+        par.pc = pc;
         spinlock_profile_iterate(spinlock_profile_ucopy_elem, &par);
         pc->time = NOW() - lock_profile_start;
-       rc = par.rc;
+        rc = par.rc;
         break;
     default:
         rc = -EINVAL;
         break;
     }
+
     return rc;
 }
 
-void _lock_profile_register_struct(int32_t type,
-    struct lock_profile_qhead *qhead, int32_t idx, char *name)
+void _lock_profile_register_struct(
+    int32_t type, struct lock_profile_qhead *qhead, int32_t idx, char *name)
 {
     qhead->idx = idx;
     spin_lock(&lock_profile_lock);
@@ -470,39 +457,41 @@ void _lock_profile_register_struct(int32
     lock_profile_ancs[type].head_q = qhead;
     lock_profile_ancs[type].name = name;
     spin_unlock(&lock_profile_lock);
-    return;
-}
-
-void _lock_profile_deregister_struct(int32_t type,
-    struct lock_profile_qhead *qhead)
+}
+
+void _lock_profile_deregister_struct(
+    int32_t type, struct lock_profile_qhead *qhead)
 {
     struct lock_profile_qhead **q;
 
     spin_lock(&lock_profile_lock);
-    for (q = &lock_profile_ancs[type].head_q; *q; q = &((*q)->head_q))
-    {
-        if (*q == qhead)
+    for ( q = &lock_profile_ancs[type].head_q; *q; q = &(*q)->head_q )
+    {
+        if ( *q == qhead )
         {
             *q = qhead->head_q;
             break;
         }
     }
     spin_unlock(&lock_profile_lock);
-    return;
 }
 
 static int __init lock_prof_init(void)
 {
     struct lock_profile **q;
 
-    for (q = &__lock_profile_start; q < &__lock_profile_end; q++)
+    for ( q = &__lock_profile_start; q < &__lock_profile_end; q++ )
     {
         (*q)->next = lock_profile_glb_q.elem_q;
-       lock_profile_glb_q.elem_q = *q;
-    }
-    _lock_profile_register_struct(LOCKPROF_TYPE_GLOBAL, &lock_profile_glb_q,
+        lock_profile_glb_q.elem_q = *q;
+    }
+
+    _lock_profile_register_struct(
+        LOCKPROF_TYPE_GLOBAL, &lock_profile_glb_q,
         0, "Global lock");
+
     return 0;
 }
 __initcall(lock_prof_init);
-#endif
+
+#endif /* LOCK_PROFILE */
diff -r cc8044c5da4c -r 9e24f7f9d7a8 xen/include/xen/spinlock.h
--- a/xen/include/xen/spinlock.h        Thu Oct 15 08:16:42 2009 +0100
+++ b/xen/include/xen/spinlock.h        Thu Oct 15 08:29:33 2009 +0100
@@ -85,12 +85,12 @@ struct lock_profile_qhead {
 #define spin_lock_init_prof(s, l)                                             \
     do {                                                                      \
         (s)->l = (spinlock_t)_SPIN_LOCK_UNLOCKED(_LOCK_PROFILE(#l));          \
-       (s)->l.profile.next = (s)->profile_head.elem_q;                       \
-       (s)->profile_head.elem_q = &((s)->l.profile);                         \
+        (s)->l.profile.next = (s)->profile_head.elem_q;                       \
+        (s)->profile_head.elem_q = &((s)->l.profile);                         \
     } while(0)
 
-void _lock_profile_register_struct(int32_t, struct lock_profile_qhead *,      \
-                                   int32_t, char *);
+void _lock_profile_register_struct(
+    int32_t, struct lock_profile_qhead *, int32_t, char *);
 void _lock_profile_deregister_struct(int32_t, struct lock_profile_qhead *);
 
 #define lock_profile_register_struct(type, ptr, idx, print)                   \

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


 


Rackspace

Lists.xenproject.org is hosted with RackSpace, monitoring our
servers 24x7x365 and backed by RackSpace's Fanatical Support®.