[TIPC]: Remove inlining of reference table locking routines

This patch converts the TIPC reference table locking routines into non-inlined routines, since they are mainly called from non-performance critical areas of TIPC and the added code footprint incurred through inlining can no longer be justified. Signed-off-by: Allan Stephens <allan.stephens@windriver.com> Signed-off-by: David S. Miller <davem@davemloft.net>

[TIPC]: Remove inlining of reference table locking routines
This patch converts the TIPC reference table locking routines into non-inlined routines, since they are mainly called from non-performance critical areas of TIPC and the added code footprint incurred through inlining can no longer be justified. Signed-off-by: Allan Stephens <allan.stephens@windriver.com> Signed-off-by: David S. Miller <davem@davemloft.net>
Allan Stephens · David S. Miller
1 parent dd9e0dda66
Showing 2 changed files with 91 additions and 89 deletions Side-by-side Diff
net/tipc/ref.c
net/tipc/ref.h
@@ -2,7 +2,7 @@
  * net/tipc/ref.c: TIPC object registry code
  *
  * Copyright (c) 1991-2006, Ericsson AB
- * Copyright (c) 2004-2005, Wind River Systems
+ * Copyright (c) 2004-2007, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -46,6 +46,37 @@
 #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 associated with object (or link to next unused entry)
+ */
+
+struct reference {
+	void *object;
+	spinlock_t lock;
+	union {
+		u32 next_plus_upper;
+		u32 reference;
+	} data;
+};
+
+/**
+ * struct tipc_ref_table - table of TIPC object reference entries
+ * @entries: pointer to array of reference entries
+ * @index_mask: bitmask for array index portion of reference values
+ * @first_free: array index of first unused object reference entry
+ * @last_free: array index of last unused object reference entry
+ */
+
+struct ref_table {
+	struct reference *entries;
+	u32 index_mask;
+	u32 first_free;
+	u32 last_free;
+};
+
 /*
  * Object reference table consists of 2**N entries.
  *
@@ -61,7 +92,7 @@
  * because entry 0's reference field has the form XXXX|1--1.
  */
  
-struct ref_table tipc_ref_table = { NULL };
+static struct ref_table tipc_ref_table = { NULL };
  
 static DEFINE_RWLOCK(ref_table_lock);
  
  
@@ -198,13 +229,65 @@
 		tipc_ref_table.first_free = index;
 	else
 		/* next_plus_upper is always XXXX|0--0 for last free entry */
-		tipc_ref_table.entries[tipc_ref_table.last_free].data.next_plus_upper
-			|= index;
+		tipc_ref_table.entries[tipc_ref_table.last_free].
+			data.next_plus_upper |= index;
 	tipc_ref_table.last_free = index;
  
 	/* increment upper bits of entry to invalidate subsequent references */
 	entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
 exit:
 	write_unlock_bh(&ref_table_lock);
+}
+
+/**
+ * tipc_ref_lock - lock referenced object and return pointer to it
+ */
+
+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];
+		spin_lock_bh(&r->lock);
+		if (likely(r->data.reference == ref))
+			return r->object;
+		spin_unlock_bh(&r->lock);
+	}
+	return NULL;
+}
+
+/**
+ * tipc_ref_unlock - unlock referenced object
+ */
+
+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];
+		if (likely(r->data.reference == ref))
+			spin_unlock_bh(&r->lock);
+		else
+			err("tipc_ref_unlock() invoked using "
+			    "obsolete reference\n");
+	}
+}
+
+/**
+ * tipc_ref_deref - return pointer referenced object (without locking it)
+ */
+
+void *tipc_ref_deref(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 == ref))
+			return r->object;
+	}
+	return NULL;
 }
@@ -2,7 +2,7 @@
  * net/tipc/ref.h: Include file for TIPC object registry code
  *
  * Copyright (c) 1991-2006, Ericsson AB
- * Copyright (c) 2005, Wind River Systems
+ * Copyright (c) 2005-2006, Wind River Systems
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  
@@ -37,96 +37,15 @@
 #ifndef _TIPC_REF_H
 #define _TIPC_REF_H
  
-/**
- * struct reference - TIPC object reference entry
- * @object: pointer to object associated with reference entry
- * @lock: spinlock controlling access to object
- * @data: reference value associated with object (or link to next unused entry)
- */
-
-struct reference {
-	void *object;
-	spinlock_t lock;
-	union {
-		u32 next_plus_upper;
-		u32 reference;
-	} data;
-};
-
-/**
- * struct tipc_ref_table - table of TIPC object reference entries
- * @entries: pointer to array of reference entries
- * @index_mask: bitmask for array index portion of reference values
- * @first_free: array index of first unused object reference entry
- * @last_free: array index of last unused object reference entry
- */
-
-struct ref_table {
-	struct reference *entries;
-	u32 index_mask;
-	u32 first_free;
-	u32 last_free;
-};
-
-extern struct ref_table tipc_ref_table;
-
 int tipc_ref_table_init(u32 requested_size, u32 start);
 void tipc_ref_table_stop(void);
  
 u32 tipc_ref_acquire(void *object, spinlock_t **lock);
 void tipc_ref_discard(u32 ref);
  
-
-/**
- * tipc_ref_lock - lock referenced object and return pointer to it
- */
-
-static inline void *tipc_ref_lock(u32 ref)
-{
-	if (likely(tipc_ref_table.entries)) {
-		struct reference *r =
-			&tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
-
-		spin_lock_bh(&r->lock);
-		if (likely(r->data.reference == ref))
-			return r->object;
-		spin_unlock_bh(&r->lock);
-	}
-	return NULL;
-}
-
-/**
- * tipc_ref_unlock - unlock referenced object
- */
-
-static inline void tipc_ref_unlock(u32 ref)
-{
-	if (likely(tipc_ref_table.entries)) {
-		struct reference *r =
-			&tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
-
-		if (likely(r->data.reference == ref))
-			spin_unlock_bh(&r->lock);
-		else
-			err("tipc_ref_unlock() invoked using obsolete reference\n");
-	}
-}
-
-/**
- * tipc_ref_deref - return pointer referenced object (without locking it)
- */
-
-static inline void *tipc_ref_deref(u32 ref)
-{
-	if (likely(tipc_ref_table.entries)) {
-		struct reference *r =
-			&tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
-
-		if (likely(r->data.reference == ref))
-			return r->object;
-	}
-	return NULL;
-}
+void *tipc_ref_lock(u32 ref);
+void tipc_ref_unlock(u32 ref);
+void *tipc_ref_deref(u32 ref);
  
 #endif
...	...	@@ -2,7 +2,7 @@
2	2	* net/tipc/ref.c: TIPC object registry code
3	3	*
4	4	* Copyright (c) 1991-2006, Ericsson AB
5		- * Copyright (c) 2004-2005, Wind River Systems
	5	+ * Copyright (c) 2004-2007, Wind River Systems
6	6	* All rights reserved.
7	7	*
8	8	* Redistribution and use in source and binary forms, with or without
...	...	@@ -46,6 +46,37 @@
46	46	#include "node.h"
47	47	#include "bcast.h"
48	48
	49	+/**
	50	+ * struct reference - TIPC object reference entry
	51	+ * @object: pointer to object associated with reference entry
	52	+ * @lock: spinlock controlling access to object
	53	+ * @data: reference value associated with object (or link to next unused entry)
	54	+ */
	55	+
	56	+struct reference {
	57	+ void *object;
	58	+ spinlock_t lock;
	59	+ union {
	60	+ u32 next_plus_upper;
	61	+ u32 reference;
	62	+ } data;
	63	+};
	64	+
	65	+/**
	66	+ * struct tipc_ref_table - table of TIPC object reference entries
	67	+ * @entries: pointer to array of reference entries
	68	+ * @index_mask: bitmask for array index portion of reference values
	69	+ * @first_free: array index of first unused object reference entry
	70	+ * @last_free: array index of last unused object reference entry
	71	+ */
	72	+
	73	+struct ref_table {
	74	+ struct reference *entries;
	75	+ u32 index_mask;
	76	+ u32 first_free;
	77	+ u32 last_free;
	78	+};
	79	+
49	80	/*
50	81	* Object reference table consists of 2**N entries.
51	82	*
...	...	@@ -61,7 +92,7 @@
61	92	* because entry 0's reference field has the form XXXX\|1--1.
62	93	*/
63	94
64		-struct ref_table tipc_ref_table = { NULL };
	95	+static struct ref_table tipc_ref_table = { NULL };
65	96
66	97	static DEFINE_RWLOCK(ref_table_lock);
67	98
68	99
...	...	@@ -198,13 +229,65 @@
198	229	tipc_ref_table.first_free = index;
199	230	else
200	231	/* next_plus_upper is always XXXX\|0--0 for last free entry */
201		- tipc_ref_table.entries[tipc_ref_table.last_free].data.next_plus_upper
202		- \|= index;
	232	+ tipc_ref_table.entries[tipc_ref_table.last_free].
	233	+ data.next_plus_upper \|= index;
203	234	tipc_ref_table.last_free = index;
204	235
205	236	/* increment upper bits of entry to invalidate subsequent references */
206	237	entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
207	238	exit:
208	239	write_unlock_bh(&ref_table_lock);
	240	+}
	241	+
	242	+/**
	243	+ * tipc_ref_lock - lock referenced object and return pointer to it
	244	+ */
	245	+
	246	+void *tipc_ref_lock(u32 ref)
	247	+{
	248	+ if (likely(tipc_ref_table.entries)) {
	249	+ struct reference *r;
	250	+
	251	+ r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
	252	+ spin_lock_bh(&r->lock);
	253	+ if (likely(r->data.reference == ref))
	254	+ return r->object;
	255	+ spin_unlock_bh(&r->lock);
	256	+ }
	257	+ return NULL;
	258	+}
	259	+
	260	+/**
	261	+ * tipc_ref_unlock - unlock referenced object
	262	+ */
	263	+
	264	+void tipc_ref_unlock(u32 ref)
	265	+{
	266	+ if (likely(tipc_ref_table.entries)) {
	267	+ struct reference *r;
	268	+
	269	+ r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
	270	+ if (likely(r->data.reference == ref))
	271	+ spin_unlock_bh(&r->lock);
	272	+ else
	273	+ err("tipc_ref_unlock() invoked using "
	274	+ "obsolete reference\n");
	275	+ }
	276	+}
	277	+
	278	+/**
	279	+ * tipc_ref_deref - return pointer referenced object (without locking it)
	280	+ */
	281	+
	282	+void *tipc_ref_deref(u32 ref)
	283	+{
	284	+ if (likely(tipc_ref_table.entries)) {
	285	+ struct reference *r;
	286	+
	287	+ r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
	288	+ if (likely(r->data.reference == ref))
	289	+ return r->object;
	290	+ }
	291	+ return NULL;
209	292	}
...	...	@@ -2,7 +2,7 @@
2	2	* net/tipc/ref.h: Include file for TIPC object registry code
3	3	*
4	4	* Copyright (c) 1991-2006, Ericsson AB
5		- * Copyright (c) 2005, Wind River Systems
	5	+ * Copyright (c) 2005-2006, Wind River Systems
6	6	* All rights reserved.
7	7	*
8	8	* Redistribution and use in source and binary forms, with or without
9	9
...	...	@@ -37,96 +37,15 @@
37	37	#ifndef _TIPC_REF_H
38	38	#define _TIPC_REF_H
39	39
40		-/**
41		- * struct reference - TIPC object reference entry
42		- * @object: pointer to object associated with reference entry
43		- * @lock: spinlock controlling access to object
44		- * @data: reference value associated with object (or link to next unused entry)
45		- */
46		-
47		-struct reference {
48		- void *object;
49		- spinlock_t lock;
50		- union {
51		- u32 next_plus_upper;
52		- u32 reference;
53		- } data;
54		-};
55		-
56		-/**
57		- * struct tipc_ref_table - table of TIPC object reference entries
58		- * @entries: pointer to array of reference entries
59		- * @index_mask: bitmask for array index portion of reference values
60		- * @first_free: array index of first unused object reference entry
61		- * @last_free: array index of last unused object reference entry
62		- */
63		-
64		-struct ref_table {
65		- struct reference *entries;
66		- u32 index_mask;
67		- u32 first_free;
68		- u32 last_free;
69		-};
70		-
71		-extern struct ref_table tipc_ref_table;
72		-
73	40	int tipc_ref_table_init(u32 requested_size, u32 start);
74	41	void tipc_ref_table_stop(void);
75	42
76	43	u32 tipc_ref_acquire(void object, spinlock_t *lock);
77	44	void tipc_ref_discard(u32 ref);
78	45
79		-
80		-/**
81		- * tipc_ref_lock - lock referenced object and return pointer to it
82		- */
83		-
84		-static inline void *tipc_ref_lock(u32 ref)
85		-{
86		- if (likely(tipc_ref_table.entries)) {
87		- struct reference *r =
88		- &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
89		-
90		- spin_lock_bh(&r->lock);
91		- if (likely(r->data.reference == ref))
92		- return r->object;
93		- spin_unlock_bh(&r->lock);
94		- }
95		- return NULL;
96		-}
97		-
98		-/**
99		- * tipc_ref_unlock - unlock referenced object
100		- */
101		-
102		-static inline void tipc_ref_unlock(u32 ref)
103		-{
104		- if (likely(tipc_ref_table.entries)) {
105		- struct reference *r =
106		- &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
107		-
108		- if (likely(r->data.reference == ref))
109		- spin_unlock_bh(&r->lock);
110		- else
111		- err("tipc_ref_unlock() invoked using obsolete reference\n");
112		- }
113		-}
114		-
115		-/**
116		- * tipc_ref_deref - return pointer referenced object (without locking it)
117		- */
118		-
119		-static inline void *tipc_ref_deref(u32 ref)
120		-{
121		- if (likely(tipc_ref_table.entries)) {
122		- struct reference *r =
123		- &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
124		-
125		- if (likely(r->data.reference == ref))
126		- return r->object;
127		- }
128		- return NULL;
129		-}
	46	+void *tipc_ref_lock(u32 ref);
	47	+void tipc_ref_unlock(u32 ref);
	48	+void *tipc_ref_deref(u32 ref);
130	49
131	50	#endif