xref: /openbmc/linux/drivers/infiniband/core/cache.c (revision d5cb9783536a41df9f9cba5b0a1d78047ed787f7)
1 /*
2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3  * Copyright (c) 2005 Intel Corporation. All rights reserved.
4  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
5  * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
6  *
7  * This software is available to you under a choice of one of two
8  * licenses.  You may choose to be licensed under the terms of the GNU
9  * General Public License (GPL) Version 2, available from the file
10  * COPYING in the main directory of this source tree, or the
11  * OpenIB.org BSD license below:
12  *
13  *     Redistribution and use in source and binary forms, with or
14  *     without modification, are permitted provided that the following
15  *     conditions are met:
16  *
17  *      - Redistributions of source code must retain the above
18  *        copyright notice, this list of conditions and the following
19  *        disclaimer.
20  *
21  *      - Redistributions in binary form must reproduce the above
22  *        copyright notice, this list of conditions and the following
23  *        disclaimer in the documentation and/or other materials
24  *        provided with the distribution.
25  *
26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33  * SOFTWARE.
34  *
35  * $Id: cache.c 1349 2004-12-16 21:09:43Z roland $
36  */
37 
38 #include <linux/module.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
41 #include <linux/sched.h>	/* INIT_WORK, schedule_work(), flush_scheduled_work() */
42 
43 #include <rdma/ib_cache.h>
44 
45 #include "core_priv.h"
46 
47 struct ib_pkey_cache {
48 	int             table_len;
49 	u16             table[0];
50 };
51 
52 struct ib_gid_cache {
53 	int             table_len;
54 	union ib_gid    table[0];
55 };
56 
57 struct ib_update_work {
58 	struct work_struct work;
59 	struct ib_device  *device;
60 	u8                 port_num;
61 };
62 
63 static inline int start_port(struct ib_device *device)
64 {
65 	return device->node_type == IB_NODE_SWITCH ? 0 : 1;
66 }
67 
68 static inline int end_port(struct ib_device *device)
69 {
70 	return device->node_type == IB_NODE_SWITCH ? 0 : device->phys_port_cnt;
71 }
72 
73 int ib_get_cached_gid(struct ib_device *device,
74 		      u8                port_num,
75 		      int               index,
76 		      union ib_gid     *gid)
77 {
78 	struct ib_gid_cache *cache;
79 	unsigned long flags;
80 	int ret = 0;
81 
82 	if (port_num < start_port(device) || port_num > end_port(device))
83 		return -EINVAL;
84 
85 	read_lock_irqsave(&device->cache.lock, flags);
86 
87 	cache = device->cache.gid_cache[port_num - start_port(device)];
88 
89 	if (index < 0 || index >= cache->table_len)
90 		ret = -EINVAL;
91 	else
92 		*gid = cache->table[index];
93 
94 	read_unlock_irqrestore(&device->cache.lock, flags);
95 
96 	return ret;
97 }
98 EXPORT_SYMBOL(ib_get_cached_gid);
99 
100 int ib_find_cached_gid(struct ib_device *device,
101 		       union ib_gid	*gid,
102 		       u8               *port_num,
103 		       u16              *index)
104 {
105 	struct ib_gid_cache *cache;
106 	unsigned long flags;
107 	int p, i;
108 	int ret = -ENOENT;
109 
110 	*port_num = -1;
111 	if (index)
112 		*index = -1;
113 
114 	read_lock_irqsave(&device->cache.lock, flags);
115 
116 	for (p = 0; p <= end_port(device) - start_port(device); ++p) {
117 		cache = device->cache.gid_cache[p];
118 		for (i = 0; i < cache->table_len; ++i) {
119 			if (!memcmp(gid, &cache->table[i], sizeof *gid)) {
120 				*port_num = p + start_port(device);
121 				if (index)
122 					*index = i;
123 				ret = 0;
124 				goto found;
125 			}
126 		}
127 	}
128 found:
129 	read_unlock_irqrestore(&device->cache.lock, flags);
130 
131 	return ret;
132 }
133 EXPORT_SYMBOL(ib_find_cached_gid);
134 
135 int ib_get_cached_pkey(struct ib_device *device,
136 		       u8                port_num,
137 		       int               index,
138 		       u16              *pkey)
139 {
140 	struct ib_pkey_cache *cache;
141 	unsigned long flags;
142 	int ret = 0;
143 
144 	if (port_num < start_port(device) || port_num > end_port(device))
145 		return -EINVAL;
146 
147 	read_lock_irqsave(&device->cache.lock, flags);
148 
149 	cache = device->cache.pkey_cache[port_num - start_port(device)];
150 
151 	if (index < 0 || index >= cache->table_len)
152 		ret = -EINVAL;
153 	else
154 		*pkey = cache->table[index];
155 
156 	read_unlock_irqrestore(&device->cache.lock, flags);
157 
158 	return ret;
159 }
160 EXPORT_SYMBOL(ib_get_cached_pkey);
161 
162 int ib_find_cached_pkey(struct ib_device *device,
163 			u8                port_num,
164 			u16               pkey,
165 			u16              *index)
166 {
167 	struct ib_pkey_cache *cache;
168 	unsigned long flags;
169 	int i;
170 	int ret = -ENOENT;
171 
172 	if (port_num < start_port(device) || port_num > end_port(device))
173 		return -EINVAL;
174 
175 	read_lock_irqsave(&device->cache.lock, flags);
176 
177 	cache = device->cache.pkey_cache[port_num - start_port(device)];
178 
179 	*index = -1;
180 
181 	for (i = 0; i < cache->table_len; ++i)
182 		if ((cache->table[i] & 0x7fff) == (pkey & 0x7fff)) {
183 			*index = i;
184 			ret = 0;
185 			break;
186 		}
187 
188 	read_unlock_irqrestore(&device->cache.lock, flags);
189 
190 	return ret;
191 }
192 EXPORT_SYMBOL(ib_find_cached_pkey);
193 
194 static void ib_cache_update(struct ib_device *device,
195 			    u8                port)
196 {
197 	struct ib_port_attr       *tprops = NULL;
198 	struct ib_pkey_cache      *pkey_cache = NULL, *old_pkey_cache;
199 	struct ib_gid_cache       *gid_cache = NULL, *old_gid_cache;
200 	int                        i;
201 	int                        ret;
202 
203 	tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
204 	if (!tprops)
205 		return;
206 
207 	ret = ib_query_port(device, port, tprops);
208 	if (ret) {
209 		printk(KERN_WARNING "ib_query_port failed (%d) for %s\n",
210 		       ret, device->name);
211 		goto err;
212 	}
213 
214 	pkey_cache = kmalloc(sizeof *pkey_cache + tprops->pkey_tbl_len *
215 			     sizeof *pkey_cache->table, GFP_KERNEL);
216 	if (!pkey_cache)
217 		goto err;
218 
219 	pkey_cache->table_len = tprops->pkey_tbl_len;
220 
221 	gid_cache = kmalloc(sizeof *gid_cache + tprops->gid_tbl_len *
222 			    sizeof *gid_cache->table, GFP_KERNEL);
223 	if (!gid_cache)
224 		goto err;
225 
226 	gid_cache->table_len = tprops->gid_tbl_len;
227 
228 	for (i = 0; i < pkey_cache->table_len; ++i) {
229 		ret = ib_query_pkey(device, port, i, pkey_cache->table + i);
230 		if (ret) {
231 			printk(KERN_WARNING "ib_query_pkey failed (%d) for %s (index %d)\n",
232 			       ret, device->name, i);
233 			goto err;
234 		}
235 	}
236 
237 	for (i = 0; i < gid_cache->table_len; ++i) {
238 		ret = ib_query_gid(device, port, i, gid_cache->table + i);
239 		if (ret) {
240 			printk(KERN_WARNING "ib_query_gid failed (%d) for %s (index %d)\n",
241 			       ret, device->name, i);
242 			goto err;
243 		}
244 	}
245 
246 	write_lock_irq(&device->cache.lock);
247 
248 	old_pkey_cache = device->cache.pkey_cache[port - start_port(device)];
249 	old_gid_cache  = device->cache.gid_cache [port - start_port(device)];
250 
251 	device->cache.pkey_cache[port - start_port(device)] = pkey_cache;
252 	device->cache.gid_cache [port - start_port(device)] = gid_cache;
253 
254 	write_unlock_irq(&device->cache.lock);
255 
256 	kfree(old_pkey_cache);
257 	kfree(old_gid_cache);
258 	kfree(tprops);
259 	return;
260 
261 err:
262 	kfree(pkey_cache);
263 	kfree(gid_cache);
264 	kfree(tprops);
265 }
266 
267 static void ib_cache_task(void *work_ptr)
268 {
269 	struct ib_update_work *work = work_ptr;
270 
271 	ib_cache_update(work->device, work->port_num);
272 	kfree(work);
273 }
274 
275 static void ib_cache_event(struct ib_event_handler *handler,
276 			   struct ib_event *event)
277 {
278 	struct ib_update_work *work;
279 
280 	if (event->event == IB_EVENT_PORT_ERR    ||
281 	    event->event == IB_EVENT_PORT_ACTIVE ||
282 	    event->event == IB_EVENT_LID_CHANGE  ||
283 	    event->event == IB_EVENT_PKEY_CHANGE ||
284 	    event->event == IB_EVENT_SM_CHANGE) {
285 		work = kmalloc(sizeof *work, GFP_ATOMIC);
286 		if (work) {
287 			INIT_WORK(&work->work, ib_cache_task, work);
288 			work->device   = event->device;
289 			work->port_num = event->element.port_num;
290 			schedule_work(&work->work);
291 		}
292 	}
293 }
294 
295 static void ib_cache_setup_one(struct ib_device *device)
296 {
297 	int p;
298 
299 	rwlock_init(&device->cache.lock);
300 
301 	device->cache.pkey_cache =
302 		kmalloc(sizeof *device->cache.pkey_cache *
303 			(end_port(device) - start_port(device) + 1), GFP_KERNEL);
304 	device->cache.gid_cache =
305 		kmalloc(sizeof *device->cache.pkey_cache *
306 			(end_port(device) - start_port(device) + 1), GFP_KERNEL);
307 
308 	if (!device->cache.pkey_cache || !device->cache.gid_cache) {
309 		printk(KERN_WARNING "Couldn't allocate cache "
310 		       "for %s\n", device->name);
311 		goto err;
312 	}
313 
314 	for (p = 0; p <= end_port(device) - start_port(device); ++p) {
315 		device->cache.pkey_cache[p] = NULL;
316 		device->cache.gid_cache [p] = NULL;
317 		ib_cache_update(device, p + start_port(device));
318 	}
319 
320 	INIT_IB_EVENT_HANDLER(&device->cache.event_handler,
321 			      device, ib_cache_event);
322 	if (ib_register_event_handler(&device->cache.event_handler))
323 		goto err_cache;
324 
325 	return;
326 
327 err_cache:
328 	for (p = 0; p <= end_port(device) - start_port(device); ++p) {
329 		kfree(device->cache.pkey_cache[p]);
330 		kfree(device->cache.gid_cache[p]);
331 	}
332 
333 err:
334 	kfree(device->cache.pkey_cache);
335 	kfree(device->cache.gid_cache);
336 }
337 
338 static void ib_cache_cleanup_one(struct ib_device *device)
339 {
340 	int p;
341 
342 	ib_unregister_event_handler(&device->cache.event_handler);
343 	flush_scheduled_work();
344 
345 	for (p = 0; p <= end_port(device) - start_port(device); ++p) {
346 		kfree(device->cache.pkey_cache[p]);
347 		kfree(device->cache.gid_cache[p]);
348 	}
349 
350 	kfree(device->cache.pkey_cache);
351 	kfree(device->cache.gid_cache);
352 }
353 
354 static struct ib_client cache_client = {
355 	.name   = "cache",
356 	.add    = ib_cache_setup_one,
357 	.remove = ib_cache_cleanup_one
358 };
359 
360 int __init ib_cache_setup(void)
361 {
362 	return ib_register_client(&cache_client);
363 }
364 
365 void __exit ib_cache_cleanup(void)
366 {
367 	ib_unregister_client(&cache_client);
368 }
369