[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [xen master] xen/spinlock: fix coding style issues
commit c9237aa2cf565eb92e0418b9da347e75c2c3156b Author: Juergen Gross <jgross@xxxxxxxx> AuthorDate: Tue Nov 21 10:05:15 2023 +0100 Commit: Jan Beulich <jbeulich@xxxxxxxx> CommitDate: Tue Nov 21 10:05:15 2023 +0100 xen/spinlock: fix coding style issues Fix some coding style issues in spinlock coding: - Instead of u64 etc. use the preferred uint64_t etc. types - Remove some trailing spaces - Add missing spaces in "if" statements - Add some missing blank lines While modifying the line, add const for the observed_head() parameter. Signed-off-by: Juergen Gross <jgross@xxxxxxxx> Acked-by: Jan Beulich <jbeulich@xxxxxxxx> --- xen/common/spinlock.c | 20 +++++++++++--------- xen/include/xen/spinlock.h | 16 ++++++++-------- 2 files changed, 19 insertions(+), 17 deletions(-) diff --git a/xen/common/spinlock.c b/xen/common/spinlock.c index 7f453234a9..d7194e518c 100644 --- a/xen/common/spinlock.c +++ b/xen/common/spinlock.c @@ -100,7 +100,7 @@ void check_lock(union lock_debug *debug, bool try) * every lock must be consistently observed else we can deadlock in * IRQ-context rendezvous functions (a rendezvous which gets every CPU * into IRQ context before any CPU is released from the rendezvous). - * + * * If we can mix IRQ-disabled and IRQ-enabled callers, the following can * happen: * * Lock is held by CPU A, with IRQs enabled @@ -108,7 +108,7 @@ void check_lock(union lock_debug *debug, bool try) * * Rendezvous starts -- CPU A takes interrupt and enters rendezbous spin * * DEADLOCK -- CPU B will never enter rendezvous, CPU A will never exit * the rendezvous, and will hence never release the lock. - * + * * To guard against this subtle bug we latch the IRQ safety of every * spinlock in the system, on first use. * @@ -151,12 +151,12 @@ static void check_barrier(union lock_debug *debug) /* * For a barrier, we have a relaxed IRQ-safety-consistency check. - * + * * It is always safe to spin at the barrier with IRQs enabled -- that does * not prevent us from entering an IRQ-context rendezvous, and nor are * we preventing anyone else from doing so (since we do not actually * acquire the lock during a barrier operation). - * + * * However, if we spin on an IRQ-unsafe lock with IRQs disabled then that * is clearly wrong, for the same reason outlined in check_lock() above. */ @@ -262,7 +262,7 @@ void spin_debug_disable(void) #ifdef CONFIG_DEBUG_LOCK_PROFILE #define LOCK_PROFILE_REL \ - if (lock->profile) \ + if ( lock->profile ) \ { \ lock->profile->time_hold += NOW() - lock->profile->time_locked; \ lock->profile->lock_cnt++; \ @@ -270,10 +270,10 @@ void spin_debug_disable(void) #define LOCK_PROFILE_VAR s_time_t block = 0 #define LOCK_PROFILE_BLOCK block = block ? : NOW(); #define LOCK_PROFILE_GOT \ - if (lock->profile) \ + if ( lock->profile ) \ { \ lock->profile->time_locked = NOW(); \ - if (block) \ + if ( block ) \ { \ lock->profile->time_block += lock->profile->time_locked - block; \ lock->profile->block_cnt++; \ @@ -298,7 +298,7 @@ static always_inline spinlock_tickets_t observe_lock(spinlock_tickets_t *t) return v; } -static always_inline u16 observe_head(spinlock_tickets_t *t) +static always_inline uint16_t observe_head(const spinlock_tickets_t *t) { smp_rmb(); return read_atomic(&t->head); @@ -412,7 +412,7 @@ int _spin_trylock(spinlock_t *lock) */ got_lock(&lock->debug); #ifdef CONFIG_DEBUG_LOCK_PROFILE - if (lock->profile) + if ( lock->profile ) lock->profile->time_locked = NOW(); #endif return 1; @@ -616,6 +616,7 @@ int spinlock_profile_control(struct xen_sysctl_lockprof_op *pc) case XEN_SYSCTL_LOCKPROF_reset: spinlock_profile_reset('\0'); break; + case XEN_SYSCTL_LOCKPROF_query: pc->nr_elem = 0; par.rc = 0; @@ -624,6 +625,7 @@ int spinlock_profile_control(struct xen_sysctl_lockprof_op *pc) pc->time = NOW() - lock_profile_start; rc = par.rc; break; + default: rc = -EINVAL; break; diff --git a/xen/include/xen/spinlock.h b/xen/include/xen/spinlock.h index 16d933ae7e..02a062a5b0 100644 --- a/xen/include/xen/spinlock.h +++ b/xen/include/xen/spinlock.h @@ -81,8 +81,8 @@ struct lock_profile { struct lock_profile *next; /* forward link */ const char *name; /* lock name */ struct spinlock *lock; /* the lock itself */ - u64 lock_cnt; /* # of complete locking ops */ - u64 block_cnt; /* # of complete wait for lock */ + uint64_t lock_cnt; /* # of complete locking ops */ + uint64_t block_cnt; /* # of complete wait for lock */ s_time_t time_hold; /* cumulated lock time */ s_time_t time_block; /* cumulated wait time */ s_time_t time_locked; /* system time of last locking */ @@ -122,7 +122,7 @@ struct lock_profile_qhead { prof->lock = &(s)->l; \ prof->next = (s)->profile_head.elem_q; \ (s)->profile_head.elem_q = prof; \ - } while(0) + } while( 0 ) void _lock_profile_register_struct( int32_t type, struct lock_profile_qhead *qhead, int32_t idx); @@ -153,10 +153,10 @@ struct lock_profile_qhead { }; #endif typedef union { - u32 head_tail; + uint32_t head_tail; struct { - u16 head; - u16 tail; + uint16_t head; + uint16_t tail; }; } spinlock_tickets_t; @@ -164,10 +164,10 @@ typedef union { typedef struct spinlock { spinlock_tickets_t tickets; - u16 recurse_cpu:SPINLOCK_CPU_BITS; + uint16_t recurse_cpu:SPINLOCK_CPU_BITS; #define SPINLOCK_NO_CPU ((1u << SPINLOCK_CPU_BITS) - 1) #define SPINLOCK_RECURSE_BITS (16 - SPINLOCK_CPU_BITS) - u16 recurse_cnt:SPINLOCK_RECURSE_BITS; + uint16_t recurse_cnt:SPINLOCK_RECURSE_BITS; #define SPINLOCK_MAX_RECURSE ((1u << SPINLOCK_RECURSE_BITS) - 1) union lock_debug debug; #ifdef CONFIG_DEBUG_LOCK_PROFILE -- generated by git-patchbot for /home/xen/git/xen.git#master
|
![]() |
Lists.xenproject.org is hosted with RackSpace, monitoring our |