From bcff122d478b774f4fd5262f35eedebe2f2fb274 Mon Sep 17 00:00:00 2001 From: Allan Stephens Date: Wed, 16 Apr 2008 18:22:20 -0700 Subject: [TIPC]: Cleanup of TIPC reference table code This patch is a largely cosmetic cleanup of the TIPC reference table code. - The object reference field in each table entry is now single 32-bit integer instead of a union of two 32-bit integers. - Variable naming has been made more consistent. - Error message output has been made more consistent. - Useless #includes have been eliminated. Signed-off-by: Allan Stephens Signed-off-by: David S. Miller --- net/tipc/ref.c | 81 ++++++++++++++++++++++++---------------------------------- 1 file changed, 34 insertions(+), 47 deletions(-) (limited to 'net/tipc') diff --git a/net/tipc/ref.c b/net/tipc/ref.c index 1853cca..89cbab2 100644 --- a/net/tipc/ref.c +++ b/net/tipc/ref.c @@ -36,30 +36,18 @@ #include "core.h" #include "ref.h" -#include "port.h" -#include "subscr.h" -#include "name_distr.h" -#include "name_table.h" -#include "config.h" -#include "discover.h" -#include "bearer.h" -#include "node.h" -#include "bcast.h" /** * struct reference - TIPC object reference entry * @object: pointer to object associated with reference entry * @lock: spinlock controlling access to object - * @data: reference value for object (combines instance & array index info) + * @ref: reference value for object (combines instance & array index info) */ struct reference { void *object; spinlock_t lock; - union { - u32 next_plus_upper; - u32 reference; - } data; + u32 ref; }; /** @@ -165,7 +153,7 @@ u32 tipc_ref_acquire(void *object, spinlock_t **lock) u32 index; u32 index_mask; u32 next_plus_upper; - u32 reference; + u32 ref; if (!object) { err("Attempt to acquire reference to non-existent object\n"); @@ -185,10 +173,10 @@ u32 tipc_ref_acquire(void *object, spinlock_t **lock) index_mask = tipc_ref_table.index_mask; /* take lock in case a previous user of entry still holds it */ spin_lock_bh(&entry->lock); - next_plus_upper = entry->data.next_plus_upper; + next_plus_upper = entry->ref; tipc_ref_table.first_free = next_plus_upper & index_mask; - reference = (next_plus_upper & ~index_mask) + index; - entry->data.reference = reference; + ref = (next_plus_upper & ~index_mask) + index; + entry->ref = ref; entry->object = object; spin_unlock_bh(&entry->lock); *lock = &entry->lock; @@ -197,17 +185,17 @@ u32 tipc_ref_acquire(void *object, spinlock_t **lock) index = tipc_ref_table.init_point++; entry = &(tipc_ref_table.entries[index]); spin_lock_init(&entry->lock); - reference = tipc_ref_table.start_mask + index; - entry->data.reference = reference; + ref = tipc_ref_table.start_mask + index; + entry->ref = ref; entry->object = object; *lock = &entry->lock; } else { - reference = 0; + ref = 0; } write_unlock_bh(&ref_table_lock); - return reference; + return ref; } /** @@ -238,26 +226,25 @@ void tipc_ref_discard(u32 ref) err("Attempt to discard reference to non-existent object\n"); goto exit; } - if (entry->data.reference != ref) { + if (entry->ref != ref) { err("Attempt to discard non-existent reference\n"); goto exit; } /* - * mark entry as unused; increment upper bits of entry's data field + * mark entry as unused; increment instance part of entry's reference * to invalidate any subsequent references */ entry->object = NULL; - entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1); + entry->ref = (ref & ~index_mask) + (index_mask + 1); /* append entry to free entry list */ if (tipc_ref_table.first_free == 0) tipc_ref_table.first_free = index; else - tipc_ref_table.entries[tipc_ref_table.last_free]. - data.next_plus_upper |= index; + tipc_ref_table.entries[tipc_ref_table.last_free].ref |= index; tipc_ref_table.last_free = index; exit: @@ -271,15 +258,15 @@ exit: void *tipc_ref_lock(u32 ref) { if (likely(tipc_ref_table.entries)) { - struct reference *r; - - r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask]; - - if (likely(r->data.reference != 0)) { - spin_lock_bh(&r->lock); - if (likely((r->data.reference == ref) && (r->object))) - return r->object; - spin_unlock_bh(&r->lock); + struct reference *entry; + + entry = &tipc_ref_table.entries[ref & + tipc_ref_table.index_mask]; + if (likely(entry->ref != 0)) { + spin_lock_bh(&entry->lock); + if (likely((entry->ref == ref) && (entry->object))) + return entry->object; + spin_unlock_bh(&entry->lock); } } return NULL; @@ -292,15 +279,14 @@ void *tipc_ref_lock(u32 ref) void tipc_ref_unlock(u32 ref) { if (likely(tipc_ref_table.entries)) { - struct reference *r; - - r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask]; + struct reference *entry; - if (likely((r->data.reference == ref) && (r->object))) - spin_unlock_bh(&r->lock); + entry = &tipc_ref_table.entries[ref & + tipc_ref_table.index_mask]; + if (likely((entry->ref == ref) && (entry->object))) + spin_unlock_bh(&entry->lock); else - err("tipc_ref_unlock() invoked using " - "invalid reference\n"); + err("Attempt to unlock non-existent reference\n"); } } @@ -311,11 +297,12 @@ void tipc_ref_unlock(u32 ref) void *tipc_ref_deref(u32 ref) { if (likely(tipc_ref_table.entries)) { - struct reference *r; + struct reference *entry; - r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask]; - if (likely(r->data.reference == ref)) - return r->object; + entry = &tipc_ref_table.entries[ref & + tipc_ref_table.index_mask]; + if (likely(entry->ref == ref)) + return entry->object; } return NULL; } -- cgit v1.1