2 * net/tipc/ref.c: TIPC object registry code
4 * Copyright (c) 1991-2006, Ericsson AB
5 * Copyright (c) 2004-2007, Wind River Systems
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. Neither the names of the copyright holders nor the names of its
17 * contributors may be used to endorse or promote products derived from
18 * this software without specific prior written permission.
20 * Alternatively, this software may be distributed under the terms of the
21 * GNU General Public License ("GPL") version 2 as published by the Free
22 * Software Foundation.
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
28 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 * POSSIBILITY OF SUCH DAMAGE.
41 #include "name_distr.h"
42 #include "name_table.h"
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)
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
74 struct reference *entries;
81 * Object reference table consists of 2**N entries.
83 * A used entry has object ptr != 0, reference == XXXX|own index
84 * (XXXX changes each time entry is acquired)
85 * A free entry has object ptr == 0, reference == YYYY|next free index
86 * (YYYY is one more than last used XXXX)
88 * Free list is initially chained from entry (2**N)-1 to entry 1.
89 * Entry 0 is not used to allow index 0 to indicate the end of the free list.
91 * Note: Any accidental reference of the form XXXX|0--0 won't match entry 0
92 * because entry 0's reference field has the form XXXX|1--1.
95 static struct ref_table tipc_ref_table = { NULL };
97 static DEFINE_RWLOCK(ref_table_lock);
100 * tipc_ref_table_init - create reference table for objects
103 int tipc_ref_table_init(u32 requested_size, u32 start)
105 struct reference *table;
110 while (sz < requested_size) {
113 table = vmalloc(sz * sizeof(*table));
117 write_lock_bh(&ref_table_lock);
119 for (i = sz - 1; i >= 0; i--) {
120 table[i].object = NULL;
121 spin_lock_init(&table[i].lock);
122 table[i].data.next_plus_upper = (start & ~index_mask) + i - 1;
124 tipc_ref_table.entries = table;
125 tipc_ref_table.index_mask = index_mask;
126 tipc_ref_table.first_free = sz - 1;
127 tipc_ref_table.last_free = 1;
128 write_unlock_bh(&ref_table_lock);
133 * tipc_ref_table_stop - destroy reference table for objects
136 void tipc_ref_table_stop(void)
138 if (!tipc_ref_table.entries)
141 vfree(tipc_ref_table.entries);
142 tipc_ref_table.entries = NULL;
146 * tipc_ref_acquire - create reference to an object
148 * Return a unique reference value which can be translated back to the pointer
149 * 'object' at a later time. Also, pass back a pointer to the lock protecting
150 * the object, but without locking it.
153 u32 tipc_ref_acquire(void *object, spinlock_t **lock)
155 struct reference *entry;
162 err("Attempt to acquire reference to non-existent object\n");
165 if (!tipc_ref_table.entries) {
166 err("Reference table not found during acquisition attempt\n");
170 write_lock_bh(&ref_table_lock);
171 if (tipc_ref_table.first_free) {
172 index = tipc_ref_table.first_free;
173 entry = &(tipc_ref_table.entries[index]);
174 index_mask = tipc_ref_table.index_mask;
175 /* take lock in case a previous user of entry still holds it */
176 spin_lock_bh(&entry->lock);
177 next_plus_upper = entry->data.next_plus_upper;
178 tipc_ref_table.first_free = next_plus_upper & index_mask;
179 reference = (next_plus_upper & ~index_mask) + index;
180 entry->data.reference = reference;
181 entry->object = object;
183 *lock = &entry->lock;
184 spin_unlock_bh(&entry->lock);
186 write_unlock_bh(&ref_table_lock);
191 * tipc_ref_discard - invalidate references to an object
193 * Disallow future references to an object and free up the entry for re-use.
194 * Note: The entry's spin_lock may still be busy after discard
197 void tipc_ref_discard(u32 ref)
199 struct reference *entry;
204 err("Attempt to discard reference 0\n");
207 if (!tipc_ref_table.entries) {
208 err("Reference table not found during discard attempt\n");
212 write_lock_bh(&ref_table_lock);
213 index_mask = tipc_ref_table.index_mask;
214 index = ref & index_mask;
215 entry = &(tipc_ref_table.entries[index]);
217 if (!entry->object) {
218 err("Attempt to discard reference to non-existent object\n");
221 if (entry->data.reference != ref) {
222 err("Attempt to discard non-existent reference\n");
226 /* mark entry as unused */
227 entry->object = NULL;
228 if (tipc_ref_table.first_free == 0)
229 tipc_ref_table.first_free = index;
231 /* next_plus_upper is always XXXX|0--0 for last free entry */
232 tipc_ref_table.entries[tipc_ref_table.last_free].
233 data.next_plus_upper |= index;
234 tipc_ref_table.last_free = index;
236 /* increment upper bits of entry to invalidate subsequent references */
237 entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1);
239 write_unlock_bh(&ref_table_lock);
243 * tipc_ref_lock - lock referenced object and return pointer to it
246 void *tipc_ref_lock(u32 ref)
248 if (likely(tipc_ref_table.entries)) {
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))
255 spin_unlock_bh(&r->lock);
261 * tipc_ref_unlock - unlock referenced object
264 void tipc_ref_unlock(u32 ref)
266 if (likely(tipc_ref_table.entries)) {
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);
273 err("tipc_ref_unlock() invoked using "
274 "obsolete reference\n");
279 * tipc_ref_deref - return pointer referenced object (without locking it)
282 void *tipc_ref_deref(u32 ref)
284 if (likely(tipc_ref_table.entries)) {
287 r = &tipc_ref_table.entries[ref & tipc_ref_table.index_mask];
288 if (likely(r->data.reference == ref))