1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37#include "core.h"
38#include "ref.h"
39
40
41
42
43
44
45
46
47struct reference {
48 void *object;
49 spinlock_t lock;
50 u32 ref;
51};
52
53
54
55
56
57
58
59
60
61
62
63
64struct ref_table {
65 struct reference *entries;
66 u32 capacity;
67 u32 init_point;
68 u32 first_free;
69 u32 last_free;
70 u32 index_mask;
71 u32 start_mask;
72};
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92static struct ref_table tipc_ref_table = { NULL };
93
94static DEFINE_RWLOCK(ref_table_lock);
95
96
97
98
99
100int tipc_ref_table_init(u32 requested_size, u32 start)
101{
102 struct reference *table;
103 u32 actual_size;
104
105
106
107 requested_size++;
108 for (actual_size = 16; actual_size < requested_size; actual_size <<= 1)
109 ;
110
111
112
113 table = __vmalloc(actual_size * sizeof(struct reference),
114 GFP_KERNEL | __GFP_HIGHMEM | __GFP_ZERO, PAGE_KERNEL);
115 if (table == NULL)
116 return -ENOMEM;
117
118 tipc_ref_table.entries = table;
119 tipc_ref_table.capacity = requested_size;
120 tipc_ref_table.init_point = 1;
121 tipc_ref_table.first_free = 0;
122 tipc_ref_table.last_free = 0;
123 tipc_ref_table.index_mask = actual_size - 1;
124 tipc_ref_table.start_mask = start & ~tipc_ref_table.index_mask;
125
126 return 0;
127}
128
129
130
131
132
133void tipc_ref_table_stop(void)
134{
135 if (!tipc_ref_table.entries)
136 return;
137
138 vfree(tipc_ref_table.entries);
139 tipc_ref_table.entries = NULL;
140}
141
142
143
144
145
146
147
148
149
150
151
152
153
154u32 tipc_ref_acquire(void *object, spinlock_t **lock)
155{
156 struct reference *entry;
157 u32 index;
158 u32 index_mask;
159 u32 next_plus_upper;
160 u32 ref;
161
162 if (!object) {
163 err("Attempt to acquire reference to non-existent object\n");
164 return 0;
165 }
166 if (!tipc_ref_table.entries) {
167 err("Reference table not found during acquisition attempt\n");
168 return 0;
169 }
170
171
172
173 write_lock_bh(&ref_table_lock);
174 if (tipc_ref_table.first_free) {
175 index = tipc_ref_table.first_free;
176 entry = &(tipc_ref_table.entries[index]);
177 index_mask = tipc_ref_table.index_mask;
178
179 spin_lock_bh(&entry->lock);
180 next_plus_upper = entry->ref;
181 tipc_ref_table.first_free = next_plus_upper & index_mask;
182 ref = (next_plus_upper & ~index_mask) + index;
183 entry->ref = ref;
184 entry->object = object;
185 *lock = &entry->lock;
186 }
187 else if (tipc_ref_table.init_point < tipc_ref_table.capacity) {
188 index = tipc_ref_table.init_point++;
189 entry = &(tipc_ref_table.entries[index]);
190 spin_lock_init(&entry->lock);
191 spin_lock_bh(&entry->lock);
192 ref = tipc_ref_table.start_mask + index;
193 entry->ref = ref;
194 entry->object = object;
195 *lock = &entry->lock;
196 }
197 else {
198 ref = 0;
199 }
200 write_unlock_bh(&ref_table_lock);
201
202 return ref;
203}
204
205
206
207
208
209
210
211
212void tipc_ref_discard(u32 ref)
213{
214 struct reference *entry;
215 u32 index;
216 u32 index_mask;
217
218 if (!tipc_ref_table.entries) {
219 err("Reference table not found during discard attempt\n");
220 return;
221 }
222
223 index_mask = tipc_ref_table.index_mask;
224 index = ref & index_mask;
225 entry = &(tipc_ref_table.entries[index]);
226
227 write_lock_bh(&ref_table_lock);
228
229 if (!entry->object) {
230 err("Attempt to discard reference to non-existent object\n");
231 goto exit;
232 }
233 if (entry->ref != ref) {
234 err("Attempt to discard non-existent reference\n");
235 goto exit;
236 }
237
238
239
240
241
242
243 entry->object = NULL;
244 entry->ref = (ref & ~index_mask) + (index_mask + 1);
245
246
247
248 if (tipc_ref_table.first_free == 0)
249 tipc_ref_table.first_free = index;
250 else
251 tipc_ref_table.entries[tipc_ref_table.last_free].ref |= index;
252 tipc_ref_table.last_free = index;
253
254exit:
255 write_unlock_bh(&ref_table_lock);
256}
257
258
259
260
261
262void *tipc_ref_lock(u32 ref)
263{
264 if (likely(tipc_ref_table.entries)) {
265 struct reference *entry;
266
267 entry = &tipc_ref_table.entries[ref &
268 tipc_ref_table.index_mask];
269 if (likely(entry->ref != 0)) {
270 spin_lock_bh(&entry->lock);
271 if (likely((entry->ref == ref) && (entry->object)))
272 return entry->object;
273 spin_unlock_bh(&entry->lock);
274 }
275 }
276 return NULL;
277}
278
279
280
281
282
283void tipc_ref_unlock(u32 ref)
284{
285 if (likely(tipc_ref_table.entries)) {
286 struct reference *entry;
287
288 entry = &tipc_ref_table.entries[ref &
289 tipc_ref_table.index_mask];
290 if (likely((entry->ref == ref) && (entry->object)))
291 spin_unlock_bh(&entry->lock);
292 else
293 err("Attempt to unlock non-existent reference\n");
294 }
295}
296
297
298
299
300
301void *tipc_ref_deref(u32 ref)
302{
303 if (likely(tipc_ref_table.entries)) {
304 struct reference *entry;
305
306 entry = &tipc_ref_table.entries[ref &
307 tipc_ref_table.index_mask];
308 if (likely(entry->ref == ref))
309 return entry->object;
310 }
311 return NULL;
312}
313