]>
Commit | Line | Data |
---|---|---|
b97bf3fd PL |
1 | /* |
2 | * net/tipc/ref.c: TIPC object registry code | |
c4307285 | 3 | * |
593a5f22 | 4 | * Copyright (c) 1991-2006, Ericsson AB |
b97bf3fd | 5 | * Copyright (c) 2004-2005, Wind River Systems |
b97bf3fd PL |
6 | * All rights reserved. |
7 | * | |
8 | * Redistribution and use in source and binary forms, with or without | |
9 | * modification, are permitted provided that the following conditions are met: | |
9ea1fd3c PL |
10 | * |
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. | |
19 | * | |
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. | |
b97bf3fd PL |
23 | * |
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. | |
35 | */ | |
36 | ||
37 | #include "core.h" | |
38 | #include "ref.h" | |
39 | #include "port.h" | |
40 | #include "subscr.h" | |
41 | #include "name_distr.h" | |
42 | #include "name_table.h" | |
43 | #include "config.h" | |
44 | #include "discover.h" | |
45 | #include "bearer.h" | |
46 | #include "node.h" | |
47 | #include "bcast.h" | |
48 | ||
49 | /* | |
50 | * Object reference table consists of 2**N entries. | |
51 | * | |
52 | * A used entry has object ptr != 0, reference == XXXX|own index | |
c4307285 | 53 | * (XXXX changes each time entry is acquired) |
b97bf3fd PL |
54 | * A free entry has object ptr == 0, reference == YYYY|next free index |
55 | * (YYYY is one more than last used XXXX) | |
56 | * | |
c4307285 | 57 | * Free list is initially chained from entry (2**N)-1 to entry 1. |
b97bf3fd PL |
58 | * Entry 0 is not used to allow index 0 to indicate the end of the free list. |
59 | * | |
60 | * Note: Any accidental reference of the form XXXX|0--0 won't match entry 0 | |
61 | * because entry 0's reference field has the form XXXX|1--1. | |
62 | */ | |
63 | ||
1fc54d8f | 64 | struct ref_table tipc_ref_table = { NULL }; |
b97bf3fd | 65 | |
34af946a | 66 | static DEFINE_RWLOCK(ref_table_lock); |
b97bf3fd PL |
67 | |
68 | /** | |
4323add6 | 69 | * tipc_ref_table_init - create reference table for objects |
b97bf3fd PL |
70 | */ |
71 | ||
4323add6 | 72 | int tipc_ref_table_init(u32 requested_size, u32 start) |
b97bf3fd PL |
73 | { |
74 | struct reference *table; | |
75 | u32 sz = 1 << 4; | |
76 | u32 index_mask; | |
77 | int i; | |
78 | ||
79 | while (sz < requested_size) { | |
80 | sz <<= 1; | |
81 | } | |
9df3f3d2 | 82 | table = vmalloc(sz * sizeof(*table)); |
b97bf3fd PL |
83 | if (table == NULL) |
84 | return -ENOMEM; | |
85 | ||
4323add6 | 86 | write_lock_bh(&ref_table_lock); |
b97bf3fd PL |
87 | index_mask = sz - 1; |
88 | for (i = sz - 1; i >= 0; i--) { | |
1fc54d8f | 89 | table[i].object = NULL; |
34af946a | 90 | spin_lock_init(&table[i].lock); |
b97bf3fd PL |
91 | table[i].data.next_plus_upper = (start & ~index_mask) + i - 1; |
92 | } | |
4323add6 PL |
93 | tipc_ref_table.entries = table; |
94 | tipc_ref_table.index_mask = index_mask; | |
95 | tipc_ref_table.first_free = sz - 1; | |
96 | tipc_ref_table.last_free = 1; | |
97 | write_unlock_bh(&ref_table_lock); | |
b97bf3fd PL |
98 | return TIPC_OK; |
99 | } | |
100 | ||
101 | /** | |
4323add6 | 102 | * tipc_ref_table_stop - destroy reference table for objects |
b97bf3fd PL |
103 | */ |
104 | ||
4323add6 | 105 | void tipc_ref_table_stop(void) |
b97bf3fd | 106 | { |
4323add6 | 107 | if (!tipc_ref_table.entries) |
b97bf3fd PL |
108 | return; |
109 | ||
4323add6 | 110 | vfree(tipc_ref_table.entries); |
1fc54d8f | 111 | tipc_ref_table.entries = NULL; |
b97bf3fd PL |
112 | } |
113 | ||
114 | /** | |
4323add6 | 115 | * tipc_ref_acquire - create reference to an object |
c4307285 | 116 | * |
b97bf3fd | 117 | * Return a unique reference value which can be translated back to the pointer |
c4307285 | 118 | * 'object' at a later time. Also, pass back a pointer to the lock protecting |
b97bf3fd PL |
119 | * the object, but without locking it. |
120 | */ | |
121 | ||
4323add6 | 122 | u32 tipc_ref_acquire(void *object, spinlock_t **lock) |
b97bf3fd PL |
123 | { |
124 | struct reference *entry; | |
125 | u32 index; | |
126 | u32 index_mask; | |
127 | u32 next_plus_upper; | |
128 | u32 reference = 0; | |
129 | ||
f131072c AS |
130 | if (!object) { |
131 | err("Attempt to acquire reference to non-existent object\n"); | |
132 | return 0; | |
133 | } | |
134 | if (!tipc_ref_table.entries) { | |
135 | err("Reference table not found during acquisition attempt\n"); | |
136 | return 0; | |
137 | } | |
b97bf3fd | 138 | |
4323add6 PL |
139 | write_lock_bh(&ref_table_lock); |
140 | if (tipc_ref_table.first_free) { | |
141 | index = tipc_ref_table.first_free; | |
142 | entry = &(tipc_ref_table.entries[index]); | |
143 | index_mask = tipc_ref_table.index_mask; | |
c4307285 YH |
144 | /* take lock in case a previous user of entry still holds it */ |
145 | spin_lock_bh(&entry->lock); | |
b97bf3fd | 146 | next_plus_upper = entry->data.next_plus_upper; |
4323add6 | 147 | tipc_ref_table.first_free = next_plus_upper & index_mask; |
b97bf3fd PL |
148 | reference = (next_plus_upper & ~index_mask) + index; |
149 | entry->data.reference = reference; | |
150 | entry->object = object; | |
5f2f40a9 | 151 | if (lock != NULL) |
c4307285 | 152 | *lock = &entry->lock; |
b97bf3fd PL |
153 | spin_unlock_bh(&entry->lock); |
154 | } | |
4323add6 | 155 | write_unlock_bh(&ref_table_lock); |
b97bf3fd PL |
156 | return reference; |
157 | } | |
158 | ||
159 | /** | |
4323add6 | 160 | * tipc_ref_discard - invalidate references to an object |
c4307285 | 161 | * |
b97bf3fd PL |
162 | * Disallow future references to an object and free up the entry for re-use. |
163 | * Note: The entry's spin_lock may still be busy after discard | |
164 | */ | |
165 | ||
4323add6 | 166 | void tipc_ref_discard(u32 ref) |
b97bf3fd PL |
167 | { |
168 | struct reference *entry; | |
c4307285 | 169 | u32 index; |
b97bf3fd PL |
170 | u32 index_mask; |
171 | ||
f131072c AS |
172 | if (!ref) { |
173 | err("Attempt to discard reference 0\n"); | |
174 | return; | |
175 | } | |
176 | if (!tipc_ref_table.entries) { | |
177 | err("Reference table not found during discard attempt\n"); | |
178 | return; | |
179 | } | |
b97bf3fd | 180 | |
4323add6 PL |
181 | write_lock_bh(&ref_table_lock); |
182 | index_mask = tipc_ref_table.index_mask; | |
b97bf3fd | 183 | index = ref & index_mask; |
4323add6 | 184 | entry = &(tipc_ref_table.entries[index]); |
f131072c AS |
185 | |
186 | if (!entry->object) { | |
187 | err("Attempt to discard reference to non-existent object\n"); | |
188 | goto exit; | |
189 | } | |
190 | if (entry->data.reference != ref) { | |
191 | err("Attempt to discard non-existent reference\n"); | |
192 | goto exit; | |
193 | } | |
b97bf3fd PL |
194 | |
195 | /* mark entry as unused */ | |
1fc54d8f | 196 | entry->object = NULL; |
4323add6 PL |
197 | if (tipc_ref_table.first_free == 0) |
198 | tipc_ref_table.first_free = index; | |
b97bf3fd PL |
199 | else |
200 | /* next_plus_upper is always XXXX|0--0 for last free entry */ | |
c4307285 | 201 | tipc_ref_table.entries[tipc_ref_table.last_free].data.next_plus_upper |
b97bf3fd | 202 | |= index; |
4323add6 | 203 | tipc_ref_table.last_free = index; |
b97bf3fd PL |
204 | |
205 | /* increment upper bits of entry to invalidate subsequent references */ | |
206 | entry->data.next_plus_upper = (ref & ~index_mask) + (index_mask + 1); | |
f131072c | 207 | exit: |
4323add6 | 208 | write_unlock_bh(&ref_table_lock); |
b97bf3fd PL |
209 | } |
210 |