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.
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:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
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.
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
35 * $Id: cache.c 1349 2004-12-16 21:09:43Z roland $
38 #include <linux/module.h>
39 #include <linux/errno.h>
40 #include <linux/slab.h>
42 #include <rdma/ib_cache.h>
44 #include "core_priv.h"
46 struct ib_pkey_cache
{
53 union ib_gid table
[0];
56 struct ib_update_work
{
57 struct work_struct work
;
58 struct ib_device
*device
;
62 static inline int start_port(struct ib_device
*device
)
64 return device
->node_type
== IB_NODE_SWITCH
? 0 : 1;
67 static inline int end_port(struct ib_device
*device
)
69 return device
->node_type
== IB_NODE_SWITCH
? 0 : device
->phys_port_cnt
;
72 int ib_get_cached_gid(struct ib_device
*device
,
77 struct ib_gid_cache
*cache
;
81 if (port_num
< start_port(device
) || port_num
> end_port(device
))
84 read_lock_irqsave(&device
->cache
.lock
, flags
);
86 cache
= device
->cache
.gid_cache
[port_num
- start_port(device
)];
88 if (index
< 0 || index
>= cache
->table_len
)
91 *gid
= cache
->table
[index
];
93 read_unlock_irqrestore(&device
->cache
.lock
, flags
);
97 EXPORT_SYMBOL(ib_get_cached_gid
);
99 int ib_find_cached_gid(struct ib_device
*device
,
104 struct ib_gid_cache
*cache
;
113 read_lock_irqsave(&device
->cache
.lock
, flags
);
115 for (p
= 0; p
<= end_port(device
) - start_port(device
); ++p
) {
116 cache
= device
->cache
.gid_cache
[p
];
117 for (i
= 0; i
< cache
->table_len
; ++i
) {
118 if (!memcmp(gid
, &cache
->table
[i
], sizeof *gid
)) {
119 *port_num
= p
+ start_port(device
);
128 read_unlock_irqrestore(&device
->cache
.lock
, flags
);
132 EXPORT_SYMBOL(ib_find_cached_gid
);
134 int ib_get_cached_pkey(struct ib_device
*device
,
139 struct ib_pkey_cache
*cache
;
143 if (port_num
< start_port(device
) || port_num
> end_port(device
))
146 read_lock_irqsave(&device
->cache
.lock
, flags
);
148 cache
= device
->cache
.pkey_cache
[port_num
- start_port(device
)];
150 if (index
< 0 || index
>= cache
->table_len
)
153 *pkey
= cache
->table
[index
];
155 read_unlock_irqrestore(&device
->cache
.lock
, flags
);
159 EXPORT_SYMBOL(ib_get_cached_pkey
);
161 int ib_find_cached_pkey(struct ib_device
*device
,
166 struct ib_pkey_cache
*cache
;
171 if (port_num
< start_port(device
) || port_num
> end_port(device
))
174 read_lock_irqsave(&device
->cache
.lock
, flags
);
176 cache
= device
->cache
.pkey_cache
[port_num
- start_port(device
)];
180 for (i
= 0; i
< cache
->table_len
; ++i
)
181 if ((cache
->table
[i
] & 0x7fff) == (pkey
& 0x7fff)) {
187 read_unlock_irqrestore(&device
->cache
.lock
, flags
);
191 EXPORT_SYMBOL(ib_find_cached_pkey
);
193 static void ib_cache_update(struct ib_device
*device
,
196 struct ib_port_attr
*tprops
= NULL
;
197 struct ib_pkey_cache
*pkey_cache
= NULL
, *old_pkey_cache
;
198 struct ib_gid_cache
*gid_cache
= NULL
, *old_gid_cache
;
202 tprops
= kmalloc(sizeof *tprops
, GFP_KERNEL
);
206 ret
= ib_query_port(device
, port
, tprops
);
208 printk(KERN_WARNING
"ib_query_port failed (%d) for %s\n",
213 pkey_cache
= kmalloc(sizeof *pkey_cache
+ tprops
->pkey_tbl_len
*
214 sizeof *pkey_cache
->table
, GFP_KERNEL
);
218 pkey_cache
->table_len
= tprops
->pkey_tbl_len
;
220 gid_cache
= kmalloc(sizeof *gid_cache
+ tprops
->gid_tbl_len
*
221 sizeof *gid_cache
->table
, GFP_KERNEL
);
225 gid_cache
->table_len
= tprops
->gid_tbl_len
;
227 for (i
= 0; i
< pkey_cache
->table_len
; ++i
) {
228 ret
= ib_query_pkey(device
, port
, i
, pkey_cache
->table
+ i
);
230 printk(KERN_WARNING
"ib_query_pkey failed (%d) for %s (index %d)\n",
231 ret
, device
->name
, i
);
236 for (i
= 0; i
< gid_cache
->table_len
; ++i
) {
237 ret
= ib_query_gid(device
, port
, i
, gid_cache
->table
+ i
);
239 printk(KERN_WARNING
"ib_query_gid failed (%d) for %s (index %d)\n",
240 ret
, device
->name
, i
);
245 write_lock_irq(&device
->cache
.lock
);
247 old_pkey_cache
= device
->cache
.pkey_cache
[port
- start_port(device
)];
248 old_gid_cache
= device
->cache
.gid_cache
[port
- start_port(device
)];
250 device
->cache
.pkey_cache
[port
- start_port(device
)] = pkey_cache
;
251 device
->cache
.gid_cache
[port
- start_port(device
)] = gid_cache
;
253 write_unlock_irq(&device
->cache
.lock
);
255 kfree(old_pkey_cache
);
256 kfree(old_gid_cache
);
266 static void ib_cache_task(void *work_ptr
)
268 struct ib_update_work
*work
= work_ptr
;
270 ib_cache_update(work
->device
, work
->port_num
);
274 static void ib_cache_event(struct ib_event_handler
*handler
,
275 struct ib_event
*event
)
277 struct ib_update_work
*work
;
279 if (event
->event
== IB_EVENT_PORT_ERR
||
280 event
->event
== IB_EVENT_PORT_ACTIVE
||
281 event
->event
== IB_EVENT_LID_CHANGE
||
282 event
->event
== IB_EVENT_PKEY_CHANGE
||
283 event
->event
== IB_EVENT_SM_CHANGE
) {
284 work
= kmalloc(sizeof *work
, GFP_ATOMIC
);
286 INIT_WORK(&work
->work
, ib_cache_task
, work
);
287 work
->device
= event
->device
;
288 work
->port_num
= event
->element
.port_num
;
289 schedule_work(&work
->work
);
294 static void ib_cache_setup_one(struct ib_device
*device
)
298 rwlock_init(&device
->cache
.lock
);
300 device
->cache
.pkey_cache
=
301 kmalloc(sizeof *device
->cache
.pkey_cache
*
302 (end_port(device
) - start_port(device
) + 1), GFP_KERNEL
);
303 device
->cache
.gid_cache
=
304 kmalloc(sizeof *device
->cache
.pkey_cache
*
305 (end_port(device
) - start_port(device
) + 1), GFP_KERNEL
);
307 if (!device
->cache
.pkey_cache
|| !device
->cache
.gid_cache
) {
308 printk(KERN_WARNING
"Couldn't allocate cache "
309 "for %s\n", device
->name
);
313 for (p
= 0; p
<= end_port(device
) - start_port(device
); ++p
) {
314 device
->cache
.pkey_cache
[p
] = NULL
;
315 device
->cache
.gid_cache
[p
] = NULL
;
316 ib_cache_update(device
, p
+ start_port(device
));
319 INIT_IB_EVENT_HANDLER(&device
->cache
.event_handler
,
320 device
, ib_cache_event
);
321 if (ib_register_event_handler(&device
->cache
.event_handler
))
327 for (p
= 0; p
<= end_port(device
) - start_port(device
); ++p
) {
328 kfree(device
->cache
.pkey_cache
[p
]);
329 kfree(device
->cache
.gid_cache
[p
]);
333 kfree(device
->cache
.pkey_cache
);
334 kfree(device
->cache
.gid_cache
);
337 static void ib_cache_cleanup_one(struct ib_device
*device
)
341 ib_unregister_event_handler(&device
->cache
.event_handler
);
342 flush_scheduled_work();
344 for (p
= 0; p
<= end_port(device
) - start_port(device
); ++p
) {
345 kfree(device
->cache
.pkey_cache
[p
]);
346 kfree(device
->cache
.gid_cache
[p
]);
349 kfree(device
->cache
.pkey_cache
);
350 kfree(device
->cache
.gid_cache
);
353 static struct ib_client cache_client
= {
355 .add
= ib_cache_setup_one
,
356 .remove
= ib_cache_cleanup_one
359 int __init
ib_cache_setup(void)
361 return ib_register_client(&cache_client
);
364 void __exit
ib_cache_cleanup(void)
366 ib_unregister_client(&cache_client
);
This page took 0.039587 seconds and 5 git commands to generate.