Loading...
1/*
2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34#include <linux/module.h>
35#include <linux/string.h>
36#include <linux/errno.h>
37#include <linux/kernel.h>
38#include <linux/slab.h>
39#include <linux/init.h>
40#include <linux/mutex.h>
41#include <rdma/rdma_netlink.h>
42
43#include "core_priv.h"
44
45MODULE_AUTHOR("Roland Dreier");
46MODULE_DESCRIPTION("core kernel InfiniBand API");
47MODULE_LICENSE("Dual BSD/GPL");
48
49struct ib_client_data {
50 struct list_head list;
51 struct ib_client *client;
52 void * data;
53};
54
55struct workqueue_struct *ib_wq;
56EXPORT_SYMBOL_GPL(ib_wq);
57
58static LIST_HEAD(device_list);
59static LIST_HEAD(client_list);
60
61/*
62 * device_mutex protects access to both device_list and client_list.
63 * There's no real point to using multiple locks or something fancier
64 * like an rwsem: we always access both lists, and we're always
65 * modifying one list or the other list. In any case this is not a
66 * hot path so there's no point in trying to optimize.
67 */
68static DEFINE_MUTEX(device_mutex);
69
70static int ib_device_check_mandatory(struct ib_device *device)
71{
72#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x }
73 static const struct {
74 size_t offset;
75 char *name;
76 } mandatory_table[] = {
77 IB_MANDATORY_FUNC(query_device),
78 IB_MANDATORY_FUNC(query_port),
79 IB_MANDATORY_FUNC(query_pkey),
80 IB_MANDATORY_FUNC(query_gid),
81 IB_MANDATORY_FUNC(alloc_pd),
82 IB_MANDATORY_FUNC(dealloc_pd),
83 IB_MANDATORY_FUNC(create_ah),
84 IB_MANDATORY_FUNC(destroy_ah),
85 IB_MANDATORY_FUNC(create_qp),
86 IB_MANDATORY_FUNC(modify_qp),
87 IB_MANDATORY_FUNC(destroy_qp),
88 IB_MANDATORY_FUNC(post_send),
89 IB_MANDATORY_FUNC(post_recv),
90 IB_MANDATORY_FUNC(create_cq),
91 IB_MANDATORY_FUNC(destroy_cq),
92 IB_MANDATORY_FUNC(poll_cq),
93 IB_MANDATORY_FUNC(req_notify_cq),
94 IB_MANDATORY_FUNC(get_dma_mr),
95 IB_MANDATORY_FUNC(dereg_mr)
96 };
97 int i;
98
99 for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
100 if (!*(void **) ((void *) device + mandatory_table[i].offset)) {
101 printk(KERN_WARNING "Device %s is missing mandatory function %s\n",
102 device->name, mandatory_table[i].name);
103 return -EINVAL;
104 }
105 }
106
107 return 0;
108}
109
110static struct ib_device *__ib_device_get_by_name(const char *name)
111{
112 struct ib_device *device;
113
114 list_for_each_entry(device, &device_list, core_list)
115 if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX))
116 return device;
117
118 return NULL;
119}
120
121
122static int alloc_name(char *name)
123{
124 unsigned long *inuse;
125 char buf[IB_DEVICE_NAME_MAX];
126 struct ib_device *device;
127 int i;
128
129 inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL);
130 if (!inuse)
131 return -ENOMEM;
132
133 list_for_each_entry(device, &device_list, core_list) {
134 if (!sscanf(device->name, name, &i))
135 continue;
136 if (i < 0 || i >= PAGE_SIZE * 8)
137 continue;
138 snprintf(buf, sizeof buf, name, i);
139 if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX))
140 set_bit(i, inuse);
141 }
142
143 i = find_first_zero_bit(inuse, PAGE_SIZE * 8);
144 free_page((unsigned long) inuse);
145 snprintf(buf, sizeof buf, name, i);
146
147 if (__ib_device_get_by_name(buf))
148 return -ENFILE;
149
150 strlcpy(name, buf, IB_DEVICE_NAME_MAX);
151 return 0;
152}
153
154static int start_port(struct ib_device *device)
155{
156 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
157}
158
159
160static int end_port(struct ib_device *device)
161{
162 return (device->node_type == RDMA_NODE_IB_SWITCH) ?
163 0 : device->phys_port_cnt;
164}
165
166/**
167 * ib_alloc_device - allocate an IB device struct
168 * @size:size of structure to allocate
169 *
170 * Low-level drivers should use ib_alloc_device() to allocate &struct
171 * ib_device. @size is the size of the structure to be allocated,
172 * including any private data used by the low-level driver.
173 * ib_dealloc_device() must be used to free structures allocated with
174 * ib_alloc_device().
175 */
176struct ib_device *ib_alloc_device(size_t size)
177{
178 BUG_ON(size < sizeof (struct ib_device));
179
180 return kzalloc(size, GFP_KERNEL);
181}
182EXPORT_SYMBOL(ib_alloc_device);
183
184/**
185 * ib_dealloc_device - free an IB device struct
186 * @device:structure to free
187 *
188 * Free a structure allocated with ib_alloc_device().
189 */
190void ib_dealloc_device(struct ib_device *device)
191{
192 if (device->reg_state == IB_DEV_UNINITIALIZED) {
193 kfree(device);
194 return;
195 }
196
197 BUG_ON(device->reg_state != IB_DEV_UNREGISTERED);
198
199 kobject_put(&device->dev.kobj);
200}
201EXPORT_SYMBOL(ib_dealloc_device);
202
203static int add_client_context(struct ib_device *device, struct ib_client *client)
204{
205 struct ib_client_data *context;
206 unsigned long flags;
207
208 context = kmalloc(sizeof *context, GFP_KERNEL);
209 if (!context) {
210 printk(KERN_WARNING "Couldn't allocate client context for %s/%s\n",
211 device->name, client->name);
212 return -ENOMEM;
213 }
214
215 context->client = client;
216 context->data = NULL;
217
218 spin_lock_irqsave(&device->client_data_lock, flags);
219 list_add(&context->list, &device->client_data_list);
220 spin_unlock_irqrestore(&device->client_data_lock, flags);
221
222 return 0;
223}
224
225static int read_port_table_lengths(struct ib_device *device)
226{
227 struct ib_port_attr *tprops = NULL;
228 int num_ports, ret = -ENOMEM;
229 u8 port_index;
230
231 tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
232 if (!tprops)
233 goto out;
234
235 num_ports = end_port(device) - start_port(device) + 1;
236
237 device->pkey_tbl_len = kmalloc(sizeof *device->pkey_tbl_len * num_ports,
238 GFP_KERNEL);
239 device->gid_tbl_len = kmalloc(sizeof *device->gid_tbl_len * num_ports,
240 GFP_KERNEL);
241 if (!device->pkey_tbl_len || !device->gid_tbl_len)
242 goto err;
243
244 for (port_index = 0; port_index < num_ports; ++port_index) {
245 ret = ib_query_port(device, port_index + start_port(device),
246 tprops);
247 if (ret)
248 goto err;
249 device->pkey_tbl_len[port_index] = tprops->pkey_tbl_len;
250 device->gid_tbl_len[port_index] = tprops->gid_tbl_len;
251 }
252
253 ret = 0;
254 goto out;
255
256err:
257 kfree(device->gid_tbl_len);
258 kfree(device->pkey_tbl_len);
259out:
260 kfree(tprops);
261 return ret;
262}
263
264/**
265 * ib_register_device - Register an IB device with IB core
266 * @device:Device to register
267 *
268 * Low-level drivers use ib_register_device() to register their
269 * devices with the IB core. All registered clients will receive a
270 * callback for each device that is added. @device must be allocated
271 * with ib_alloc_device().
272 */
273int ib_register_device(struct ib_device *device,
274 int (*port_callback)(struct ib_device *,
275 u8, struct kobject *))
276{
277 int ret;
278
279 mutex_lock(&device_mutex);
280
281 if (strchr(device->name, '%')) {
282 ret = alloc_name(device->name);
283 if (ret)
284 goto out;
285 }
286
287 if (ib_device_check_mandatory(device)) {
288 ret = -EINVAL;
289 goto out;
290 }
291
292 INIT_LIST_HEAD(&device->event_handler_list);
293 INIT_LIST_HEAD(&device->client_data_list);
294 spin_lock_init(&device->event_handler_lock);
295 spin_lock_init(&device->client_data_lock);
296
297 ret = read_port_table_lengths(device);
298 if (ret) {
299 printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n",
300 device->name);
301 goto out;
302 }
303
304 ret = ib_device_register_sysfs(device, port_callback);
305 if (ret) {
306 printk(KERN_WARNING "Couldn't register device %s with driver model\n",
307 device->name);
308 kfree(device->gid_tbl_len);
309 kfree(device->pkey_tbl_len);
310 goto out;
311 }
312
313 list_add_tail(&device->core_list, &device_list);
314
315 device->reg_state = IB_DEV_REGISTERED;
316
317 {
318 struct ib_client *client;
319
320 list_for_each_entry(client, &client_list, list)
321 if (client->add && !add_client_context(device, client))
322 client->add(device);
323 }
324
325 out:
326 mutex_unlock(&device_mutex);
327 return ret;
328}
329EXPORT_SYMBOL(ib_register_device);
330
331/**
332 * ib_unregister_device - Unregister an IB device
333 * @device:Device to unregister
334 *
335 * Unregister an IB device. All clients will receive a remove callback.
336 */
337void ib_unregister_device(struct ib_device *device)
338{
339 struct ib_client *client;
340 struct ib_client_data *context, *tmp;
341 unsigned long flags;
342
343 mutex_lock(&device_mutex);
344
345 list_for_each_entry_reverse(client, &client_list, list)
346 if (client->remove)
347 client->remove(device);
348
349 list_del(&device->core_list);
350
351 kfree(device->gid_tbl_len);
352 kfree(device->pkey_tbl_len);
353
354 mutex_unlock(&device_mutex);
355
356 ib_device_unregister_sysfs(device);
357
358 spin_lock_irqsave(&device->client_data_lock, flags);
359 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
360 kfree(context);
361 spin_unlock_irqrestore(&device->client_data_lock, flags);
362
363 device->reg_state = IB_DEV_UNREGISTERED;
364}
365EXPORT_SYMBOL(ib_unregister_device);
366
367/**
368 * ib_register_client - Register an IB client
369 * @client:Client to register
370 *
371 * Upper level users of the IB drivers can use ib_register_client() to
372 * register callbacks for IB device addition and removal. When an IB
373 * device is added, each registered client's add method will be called
374 * (in the order the clients were registered), and when a device is
375 * removed, each client's remove method will be called (in the reverse
376 * order that clients were registered). In addition, when
377 * ib_register_client() is called, the client will receive an add
378 * callback for all devices already registered.
379 */
380int ib_register_client(struct ib_client *client)
381{
382 struct ib_device *device;
383
384 mutex_lock(&device_mutex);
385
386 list_add_tail(&client->list, &client_list);
387 list_for_each_entry(device, &device_list, core_list)
388 if (client->add && !add_client_context(device, client))
389 client->add(device);
390
391 mutex_unlock(&device_mutex);
392
393 return 0;
394}
395EXPORT_SYMBOL(ib_register_client);
396
397/**
398 * ib_unregister_client - Unregister an IB client
399 * @client:Client to unregister
400 *
401 * Upper level users use ib_unregister_client() to remove their client
402 * registration. When ib_unregister_client() is called, the client
403 * will receive a remove callback for each IB device still registered.
404 */
405void ib_unregister_client(struct ib_client *client)
406{
407 struct ib_client_data *context, *tmp;
408 struct ib_device *device;
409 unsigned long flags;
410
411 mutex_lock(&device_mutex);
412
413 list_for_each_entry(device, &device_list, core_list) {
414 if (client->remove)
415 client->remove(device);
416
417 spin_lock_irqsave(&device->client_data_lock, flags);
418 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
419 if (context->client == client) {
420 list_del(&context->list);
421 kfree(context);
422 }
423 spin_unlock_irqrestore(&device->client_data_lock, flags);
424 }
425 list_del(&client->list);
426
427 mutex_unlock(&device_mutex);
428}
429EXPORT_SYMBOL(ib_unregister_client);
430
431/**
432 * ib_get_client_data - Get IB client context
433 * @device:Device to get context for
434 * @client:Client to get context for
435 *
436 * ib_get_client_data() returns client context set with
437 * ib_set_client_data().
438 */
439void *ib_get_client_data(struct ib_device *device, struct ib_client *client)
440{
441 struct ib_client_data *context;
442 void *ret = NULL;
443 unsigned long flags;
444
445 spin_lock_irqsave(&device->client_data_lock, flags);
446 list_for_each_entry(context, &device->client_data_list, list)
447 if (context->client == client) {
448 ret = context->data;
449 break;
450 }
451 spin_unlock_irqrestore(&device->client_data_lock, flags);
452
453 return ret;
454}
455EXPORT_SYMBOL(ib_get_client_data);
456
457/**
458 * ib_set_client_data - Set IB client context
459 * @device:Device to set context for
460 * @client:Client to set context for
461 * @data:Context to set
462 *
463 * ib_set_client_data() sets client context that can be retrieved with
464 * ib_get_client_data().
465 */
466void ib_set_client_data(struct ib_device *device, struct ib_client *client,
467 void *data)
468{
469 struct ib_client_data *context;
470 unsigned long flags;
471
472 spin_lock_irqsave(&device->client_data_lock, flags);
473 list_for_each_entry(context, &device->client_data_list, list)
474 if (context->client == client) {
475 context->data = data;
476 goto out;
477 }
478
479 printk(KERN_WARNING "No client context found for %s/%s\n",
480 device->name, client->name);
481
482out:
483 spin_unlock_irqrestore(&device->client_data_lock, flags);
484}
485EXPORT_SYMBOL(ib_set_client_data);
486
487/**
488 * ib_register_event_handler - Register an IB event handler
489 * @event_handler:Handler to register
490 *
491 * ib_register_event_handler() registers an event handler that will be
492 * called back when asynchronous IB events occur (as defined in
493 * chapter 11 of the InfiniBand Architecture Specification). This
494 * callback may occur in interrupt context.
495 */
496int ib_register_event_handler (struct ib_event_handler *event_handler)
497{
498 unsigned long flags;
499
500 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
501 list_add_tail(&event_handler->list,
502 &event_handler->device->event_handler_list);
503 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
504
505 return 0;
506}
507EXPORT_SYMBOL(ib_register_event_handler);
508
509/**
510 * ib_unregister_event_handler - Unregister an event handler
511 * @event_handler:Handler to unregister
512 *
513 * Unregister an event handler registered with
514 * ib_register_event_handler().
515 */
516int ib_unregister_event_handler(struct ib_event_handler *event_handler)
517{
518 unsigned long flags;
519
520 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
521 list_del(&event_handler->list);
522 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
523
524 return 0;
525}
526EXPORT_SYMBOL(ib_unregister_event_handler);
527
528/**
529 * ib_dispatch_event - Dispatch an asynchronous event
530 * @event:Event to dispatch
531 *
532 * Low-level drivers must call ib_dispatch_event() to dispatch the
533 * event to all registered event handlers when an asynchronous event
534 * occurs.
535 */
536void ib_dispatch_event(struct ib_event *event)
537{
538 unsigned long flags;
539 struct ib_event_handler *handler;
540
541 spin_lock_irqsave(&event->device->event_handler_lock, flags);
542
543 list_for_each_entry(handler, &event->device->event_handler_list, list)
544 handler->handler(handler, event);
545
546 spin_unlock_irqrestore(&event->device->event_handler_lock, flags);
547}
548EXPORT_SYMBOL(ib_dispatch_event);
549
550/**
551 * ib_query_device - Query IB device attributes
552 * @device:Device to query
553 * @device_attr:Device attributes
554 *
555 * ib_query_device() returns the attributes of a device through the
556 * @device_attr pointer.
557 */
558int ib_query_device(struct ib_device *device,
559 struct ib_device_attr *device_attr)
560{
561 return device->query_device(device, device_attr);
562}
563EXPORT_SYMBOL(ib_query_device);
564
565/**
566 * ib_query_port - Query IB port attributes
567 * @device:Device to query
568 * @port_num:Port number to query
569 * @port_attr:Port attributes
570 *
571 * ib_query_port() returns the attributes of a port through the
572 * @port_attr pointer.
573 */
574int ib_query_port(struct ib_device *device,
575 u8 port_num,
576 struct ib_port_attr *port_attr)
577{
578 if (port_num < start_port(device) || port_num > end_port(device))
579 return -EINVAL;
580
581 return device->query_port(device, port_num, port_attr);
582}
583EXPORT_SYMBOL(ib_query_port);
584
585/**
586 * ib_query_gid - Get GID table entry
587 * @device:Device to query
588 * @port_num:Port number to query
589 * @index:GID table index to query
590 * @gid:Returned GID
591 *
592 * ib_query_gid() fetches the specified GID table entry.
593 */
594int ib_query_gid(struct ib_device *device,
595 u8 port_num, int index, union ib_gid *gid)
596{
597 return device->query_gid(device, port_num, index, gid);
598}
599EXPORT_SYMBOL(ib_query_gid);
600
601/**
602 * ib_query_pkey - Get P_Key table entry
603 * @device:Device to query
604 * @port_num:Port number to query
605 * @index:P_Key table index to query
606 * @pkey:Returned P_Key
607 *
608 * ib_query_pkey() fetches the specified P_Key table entry.
609 */
610int ib_query_pkey(struct ib_device *device,
611 u8 port_num, u16 index, u16 *pkey)
612{
613 return device->query_pkey(device, port_num, index, pkey);
614}
615EXPORT_SYMBOL(ib_query_pkey);
616
617/**
618 * ib_modify_device - Change IB device attributes
619 * @device:Device to modify
620 * @device_modify_mask:Mask of attributes to change
621 * @device_modify:New attribute values
622 *
623 * ib_modify_device() changes a device's attributes as specified by
624 * the @device_modify_mask and @device_modify structure.
625 */
626int ib_modify_device(struct ib_device *device,
627 int device_modify_mask,
628 struct ib_device_modify *device_modify)
629{
630 if (!device->modify_device)
631 return -ENOSYS;
632
633 return device->modify_device(device, device_modify_mask,
634 device_modify);
635}
636EXPORT_SYMBOL(ib_modify_device);
637
638/**
639 * ib_modify_port - Modifies the attributes for the specified port.
640 * @device: The device to modify.
641 * @port_num: The number of the port to modify.
642 * @port_modify_mask: Mask used to specify which attributes of the port
643 * to change.
644 * @port_modify: New attribute values for the port.
645 *
646 * ib_modify_port() changes a port's attributes as specified by the
647 * @port_modify_mask and @port_modify structure.
648 */
649int ib_modify_port(struct ib_device *device,
650 u8 port_num, int port_modify_mask,
651 struct ib_port_modify *port_modify)
652{
653 if (!device->modify_port)
654 return -ENOSYS;
655
656 if (port_num < start_port(device) || port_num > end_port(device))
657 return -EINVAL;
658
659 return device->modify_port(device, port_num, port_modify_mask,
660 port_modify);
661}
662EXPORT_SYMBOL(ib_modify_port);
663
664/**
665 * ib_find_gid - Returns the port number and GID table index where
666 * a specified GID value occurs.
667 * @device: The device to query.
668 * @gid: The GID value to search for.
669 * @port_num: The port number of the device where the GID value was found.
670 * @index: The index into the GID table where the GID was found. This
671 * parameter may be NULL.
672 */
673int ib_find_gid(struct ib_device *device, union ib_gid *gid,
674 u8 *port_num, u16 *index)
675{
676 union ib_gid tmp_gid;
677 int ret, port, i;
678
679 for (port = start_port(device); port <= end_port(device); ++port) {
680 for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) {
681 ret = ib_query_gid(device, port, i, &tmp_gid);
682 if (ret)
683 return ret;
684 if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
685 *port_num = port;
686 if (index)
687 *index = i;
688 return 0;
689 }
690 }
691 }
692
693 return -ENOENT;
694}
695EXPORT_SYMBOL(ib_find_gid);
696
697/**
698 * ib_find_pkey - Returns the PKey table index where a specified
699 * PKey value occurs.
700 * @device: The device to query.
701 * @port_num: The port number of the device to search for the PKey.
702 * @pkey: The PKey value to search for.
703 * @index: The index into the PKey table where the PKey was found.
704 */
705int ib_find_pkey(struct ib_device *device,
706 u8 port_num, u16 pkey, u16 *index)
707{
708 int ret, i;
709 u16 tmp_pkey;
710
711 for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) {
712 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
713 if (ret)
714 return ret;
715
716 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
717 *index = i;
718 return 0;
719 }
720 }
721
722 return -ENOENT;
723}
724EXPORT_SYMBOL(ib_find_pkey);
725
726static int __init ib_core_init(void)
727{
728 int ret;
729
730 ib_wq = alloc_workqueue("infiniband", 0, 0);
731 if (!ib_wq)
732 return -ENOMEM;
733
734 ret = ib_sysfs_setup();
735 if (ret) {
736 printk(KERN_WARNING "Couldn't create InfiniBand device class\n");
737 goto err;
738 }
739
740 ret = ibnl_init();
741 if (ret) {
742 printk(KERN_WARNING "Couldn't init IB netlink interface\n");
743 goto err_sysfs;
744 }
745
746 ret = ib_cache_setup();
747 if (ret) {
748 printk(KERN_WARNING "Couldn't set up InfiniBand P_Key/GID cache\n");
749 goto err_nl;
750 }
751
752 return 0;
753
754err_nl:
755 ibnl_cleanup();
756
757err_sysfs:
758 ib_sysfs_cleanup();
759
760err:
761 destroy_workqueue(ib_wq);
762 return ret;
763}
764
765static void __exit ib_core_cleanup(void)
766{
767 ib_cache_cleanup();
768 ibnl_cleanup();
769 ib_sysfs_cleanup();
770 /* Make sure that any pending umem accounting work is done. */
771 destroy_workqueue(ib_wq);
772}
773
774module_init(ib_core_init);
775module_exit(ib_core_cleanup);
1/*
2 * Copyright (c) 2004 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34#include <linux/module.h>
35#include <linux/string.h>
36#include <linux/errno.h>
37#include <linux/kernel.h>
38#include <linux/slab.h>
39#include <linux/init.h>
40#include <linux/mutex.h>
41#include <linux/netdevice.h>
42#include <rdma/rdma_netlink.h>
43#include <rdma/ib_addr.h>
44#include <rdma/ib_cache.h>
45
46#include "core_priv.h"
47
48MODULE_AUTHOR("Roland Dreier");
49MODULE_DESCRIPTION("core kernel InfiniBand API");
50MODULE_LICENSE("Dual BSD/GPL");
51
52struct ib_client_data {
53 struct list_head list;
54 struct ib_client *client;
55 void * data;
56 /* The device or client is going down. Do not call client or device
57 * callbacks other than remove(). */
58 bool going_down;
59};
60
61struct workqueue_struct *ib_comp_wq;
62struct workqueue_struct *ib_wq;
63EXPORT_SYMBOL_GPL(ib_wq);
64
65/* The device_list and client_list contain devices and clients after their
66 * registration has completed, and the devices and clients are removed
67 * during unregistration. */
68static LIST_HEAD(device_list);
69static LIST_HEAD(client_list);
70
71/*
72 * device_mutex and lists_rwsem protect access to both device_list and
73 * client_list. device_mutex protects writer access by device and client
74 * registration / de-registration. lists_rwsem protects reader access to
75 * these lists. Iterators of these lists must lock it for read, while updates
76 * to the lists must be done with a write lock. A special case is when the
77 * device_mutex is locked. In this case locking the lists for read access is
78 * not necessary as the device_mutex implies it.
79 *
80 * lists_rwsem also protects access to the client data list.
81 */
82static DEFINE_MUTEX(device_mutex);
83static DECLARE_RWSEM(lists_rwsem);
84
85
86static int ib_device_check_mandatory(struct ib_device *device)
87{
88#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x }
89 static const struct {
90 size_t offset;
91 char *name;
92 } mandatory_table[] = {
93 IB_MANDATORY_FUNC(query_device),
94 IB_MANDATORY_FUNC(query_port),
95 IB_MANDATORY_FUNC(query_pkey),
96 IB_MANDATORY_FUNC(query_gid),
97 IB_MANDATORY_FUNC(alloc_pd),
98 IB_MANDATORY_FUNC(dealloc_pd),
99 IB_MANDATORY_FUNC(create_ah),
100 IB_MANDATORY_FUNC(destroy_ah),
101 IB_MANDATORY_FUNC(create_qp),
102 IB_MANDATORY_FUNC(modify_qp),
103 IB_MANDATORY_FUNC(destroy_qp),
104 IB_MANDATORY_FUNC(post_send),
105 IB_MANDATORY_FUNC(post_recv),
106 IB_MANDATORY_FUNC(create_cq),
107 IB_MANDATORY_FUNC(destroy_cq),
108 IB_MANDATORY_FUNC(poll_cq),
109 IB_MANDATORY_FUNC(req_notify_cq),
110 IB_MANDATORY_FUNC(get_dma_mr),
111 IB_MANDATORY_FUNC(dereg_mr),
112 IB_MANDATORY_FUNC(get_port_immutable)
113 };
114 int i;
115
116 for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
117 if (!*(void **) ((void *) device + mandatory_table[i].offset)) {
118 pr_warn("Device %s is missing mandatory function %s\n",
119 device->name, mandatory_table[i].name);
120 return -EINVAL;
121 }
122 }
123
124 return 0;
125}
126
127static struct ib_device *__ib_device_get_by_name(const char *name)
128{
129 struct ib_device *device;
130
131 list_for_each_entry(device, &device_list, core_list)
132 if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX))
133 return device;
134
135 return NULL;
136}
137
138
139static int alloc_name(char *name)
140{
141 unsigned long *inuse;
142 char buf[IB_DEVICE_NAME_MAX];
143 struct ib_device *device;
144 int i;
145
146 inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL);
147 if (!inuse)
148 return -ENOMEM;
149
150 list_for_each_entry(device, &device_list, core_list) {
151 if (!sscanf(device->name, name, &i))
152 continue;
153 if (i < 0 || i >= PAGE_SIZE * 8)
154 continue;
155 snprintf(buf, sizeof buf, name, i);
156 if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX))
157 set_bit(i, inuse);
158 }
159
160 i = find_first_zero_bit(inuse, PAGE_SIZE * 8);
161 free_page((unsigned long) inuse);
162 snprintf(buf, sizeof buf, name, i);
163
164 if (__ib_device_get_by_name(buf))
165 return -ENFILE;
166
167 strlcpy(name, buf, IB_DEVICE_NAME_MAX);
168 return 0;
169}
170
171static void ib_device_release(struct device *device)
172{
173 struct ib_device *dev = container_of(device, struct ib_device, dev);
174
175 ib_cache_release_one(dev);
176 kfree(dev->port_immutable);
177 kfree(dev);
178}
179
180static int ib_device_uevent(struct device *device,
181 struct kobj_uevent_env *env)
182{
183 struct ib_device *dev = container_of(device, struct ib_device, dev);
184
185 if (add_uevent_var(env, "NAME=%s", dev->name))
186 return -ENOMEM;
187
188 /*
189 * It would be nice to pass the node GUID with the event...
190 */
191
192 return 0;
193}
194
195static struct class ib_class = {
196 .name = "infiniband",
197 .dev_release = ib_device_release,
198 .dev_uevent = ib_device_uevent,
199};
200
201/**
202 * ib_alloc_device - allocate an IB device struct
203 * @size:size of structure to allocate
204 *
205 * Low-level drivers should use ib_alloc_device() to allocate &struct
206 * ib_device. @size is the size of the structure to be allocated,
207 * including any private data used by the low-level driver.
208 * ib_dealloc_device() must be used to free structures allocated with
209 * ib_alloc_device().
210 */
211struct ib_device *ib_alloc_device(size_t size)
212{
213 struct ib_device *device;
214
215 if (WARN_ON(size < sizeof(struct ib_device)))
216 return NULL;
217
218 device = kzalloc(size, GFP_KERNEL);
219 if (!device)
220 return NULL;
221
222 device->dev.class = &ib_class;
223 device_initialize(&device->dev);
224
225 dev_set_drvdata(&device->dev, device);
226
227 INIT_LIST_HEAD(&device->event_handler_list);
228 spin_lock_init(&device->event_handler_lock);
229 spin_lock_init(&device->client_data_lock);
230 INIT_LIST_HEAD(&device->client_data_list);
231 INIT_LIST_HEAD(&device->port_list);
232
233 return device;
234}
235EXPORT_SYMBOL(ib_alloc_device);
236
237/**
238 * ib_dealloc_device - free an IB device struct
239 * @device:structure to free
240 *
241 * Free a structure allocated with ib_alloc_device().
242 */
243void ib_dealloc_device(struct ib_device *device)
244{
245 WARN_ON(device->reg_state != IB_DEV_UNREGISTERED &&
246 device->reg_state != IB_DEV_UNINITIALIZED);
247 kobject_put(&device->dev.kobj);
248}
249EXPORT_SYMBOL(ib_dealloc_device);
250
251static int add_client_context(struct ib_device *device, struct ib_client *client)
252{
253 struct ib_client_data *context;
254 unsigned long flags;
255
256 context = kmalloc(sizeof *context, GFP_KERNEL);
257 if (!context)
258 return -ENOMEM;
259
260 context->client = client;
261 context->data = NULL;
262 context->going_down = false;
263
264 down_write(&lists_rwsem);
265 spin_lock_irqsave(&device->client_data_lock, flags);
266 list_add(&context->list, &device->client_data_list);
267 spin_unlock_irqrestore(&device->client_data_lock, flags);
268 up_write(&lists_rwsem);
269
270 return 0;
271}
272
273static int verify_immutable(const struct ib_device *dev, u8 port)
274{
275 return WARN_ON(!rdma_cap_ib_mad(dev, port) &&
276 rdma_max_mad_size(dev, port) != 0);
277}
278
279static int read_port_immutable(struct ib_device *device)
280{
281 int ret;
282 u8 start_port = rdma_start_port(device);
283 u8 end_port = rdma_end_port(device);
284 u8 port;
285
286 /**
287 * device->port_immutable is indexed directly by the port number to make
288 * access to this data as efficient as possible.
289 *
290 * Therefore port_immutable is declared as a 1 based array with
291 * potential empty slots at the beginning.
292 */
293 device->port_immutable = kzalloc(sizeof(*device->port_immutable)
294 * (end_port + 1),
295 GFP_KERNEL);
296 if (!device->port_immutable)
297 return -ENOMEM;
298
299 for (port = start_port; port <= end_port; ++port) {
300 ret = device->get_port_immutable(device, port,
301 &device->port_immutable[port]);
302 if (ret)
303 return ret;
304
305 if (verify_immutable(device, port))
306 return -EINVAL;
307 }
308 return 0;
309}
310
311void ib_get_device_fw_str(struct ib_device *dev, char *str, size_t str_len)
312{
313 if (dev->get_dev_fw_str)
314 dev->get_dev_fw_str(dev, str, str_len);
315 else
316 str[0] = '\0';
317}
318EXPORT_SYMBOL(ib_get_device_fw_str);
319
320/**
321 * ib_register_device - Register an IB device with IB core
322 * @device:Device to register
323 *
324 * Low-level drivers use ib_register_device() to register their
325 * devices with the IB core. All registered clients will receive a
326 * callback for each device that is added. @device must be allocated
327 * with ib_alloc_device().
328 */
329int ib_register_device(struct ib_device *device,
330 int (*port_callback)(struct ib_device *,
331 u8, struct kobject *))
332{
333 int ret;
334 struct ib_client *client;
335 struct ib_udata uhw = {.outlen = 0, .inlen = 0};
336
337 mutex_lock(&device_mutex);
338
339 if (strchr(device->name, '%')) {
340 ret = alloc_name(device->name);
341 if (ret)
342 goto out;
343 }
344
345 if (ib_device_check_mandatory(device)) {
346 ret = -EINVAL;
347 goto out;
348 }
349
350 ret = read_port_immutable(device);
351 if (ret) {
352 pr_warn("Couldn't create per port immutable data %s\n",
353 device->name);
354 goto out;
355 }
356
357 ret = ib_cache_setup_one(device);
358 if (ret) {
359 pr_warn("Couldn't set up InfiniBand P_Key/GID cache\n");
360 goto out;
361 }
362
363 memset(&device->attrs, 0, sizeof(device->attrs));
364 ret = device->query_device(device, &device->attrs, &uhw);
365 if (ret) {
366 pr_warn("Couldn't query the device attributes\n");
367 ib_cache_cleanup_one(device);
368 goto out;
369 }
370
371 ret = ib_device_register_sysfs(device, port_callback);
372 if (ret) {
373 pr_warn("Couldn't register device %s with driver model\n",
374 device->name);
375 ib_cache_cleanup_one(device);
376 goto out;
377 }
378
379 device->reg_state = IB_DEV_REGISTERED;
380
381 list_for_each_entry(client, &client_list, list)
382 if (client->add && !add_client_context(device, client))
383 client->add(device);
384
385 down_write(&lists_rwsem);
386 list_add_tail(&device->core_list, &device_list);
387 up_write(&lists_rwsem);
388out:
389 mutex_unlock(&device_mutex);
390 return ret;
391}
392EXPORT_SYMBOL(ib_register_device);
393
394/**
395 * ib_unregister_device - Unregister an IB device
396 * @device:Device to unregister
397 *
398 * Unregister an IB device. All clients will receive a remove callback.
399 */
400void ib_unregister_device(struct ib_device *device)
401{
402 struct ib_client_data *context, *tmp;
403 unsigned long flags;
404
405 mutex_lock(&device_mutex);
406
407 down_write(&lists_rwsem);
408 list_del(&device->core_list);
409 spin_lock_irqsave(&device->client_data_lock, flags);
410 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
411 context->going_down = true;
412 spin_unlock_irqrestore(&device->client_data_lock, flags);
413 downgrade_write(&lists_rwsem);
414
415 list_for_each_entry_safe(context, tmp, &device->client_data_list,
416 list) {
417 if (context->client->remove)
418 context->client->remove(device, context->data);
419 }
420 up_read(&lists_rwsem);
421
422 mutex_unlock(&device_mutex);
423
424 ib_device_unregister_sysfs(device);
425 ib_cache_cleanup_one(device);
426
427 down_write(&lists_rwsem);
428 spin_lock_irqsave(&device->client_data_lock, flags);
429 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
430 kfree(context);
431 spin_unlock_irqrestore(&device->client_data_lock, flags);
432 up_write(&lists_rwsem);
433
434 device->reg_state = IB_DEV_UNREGISTERED;
435}
436EXPORT_SYMBOL(ib_unregister_device);
437
438/**
439 * ib_register_client - Register an IB client
440 * @client:Client to register
441 *
442 * Upper level users of the IB drivers can use ib_register_client() to
443 * register callbacks for IB device addition and removal. When an IB
444 * device is added, each registered client's add method will be called
445 * (in the order the clients were registered), and when a device is
446 * removed, each client's remove method will be called (in the reverse
447 * order that clients were registered). In addition, when
448 * ib_register_client() is called, the client will receive an add
449 * callback for all devices already registered.
450 */
451int ib_register_client(struct ib_client *client)
452{
453 struct ib_device *device;
454
455 mutex_lock(&device_mutex);
456
457 list_for_each_entry(device, &device_list, core_list)
458 if (client->add && !add_client_context(device, client))
459 client->add(device);
460
461 down_write(&lists_rwsem);
462 list_add_tail(&client->list, &client_list);
463 up_write(&lists_rwsem);
464
465 mutex_unlock(&device_mutex);
466
467 return 0;
468}
469EXPORT_SYMBOL(ib_register_client);
470
471/**
472 * ib_unregister_client - Unregister an IB client
473 * @client:Client to unregister
474 *
475 * Upper level users use ib_unregister_client() to remove their client
476 * registration. When ib_unregister_client() is called, the client
477 * will receive a remove callback for each IB device still registered.
478 */
479void ib_unregister_client(struct ib_client *client)
480{
481 struct ib_client_data *context, *tmp;
482 struct ib_device *device;
483 unsigned long flags;
484
485 mutex_lock(&device_mutex);
486
487 down_write(&lists_rwsem);
488 list_del(&client->list);
489 up_write(&lists_rwsem);
490
491 list_for_each_entry(device, &device_list, core_list) {
492 struct ib_client_data *found_context = NULL;
493
494 down_write(&lists_rwsem);
495 spin_lock_irqsave(&device->client_data_lock, flags);
496 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
497 if (context->client == client) {
498 context->going_down = true;
499 found_context = context;
500 break;
501 }
502 spin_unlock_irqrestore(&device->client_data_lock, flags);
503 up_write(&lists_rwsem);
504
505 if (client->remove)
506 client->remove(device, found_context ?
507 found_context->data : NULL);
508
509 if (!found_context) {
510 pr_warn("No client context found for %s/%s\n",
511 device->name, client->name);
512 continue;
513 }
514
515 down_write(&lists_rwsem);
516 spin_lock_irqsave(&device->client_data_lock, flags);
517 list_del(&found_context->list);
518 kfree(found_context);
519 spin_unlock_irqrestore(&device->client_data_lock, flags);
520 up_write(&lists_rwsem);
521 }
522
523 mutex_unlock(&device_mutex);
524}
525EXPORT_SYMBOL(ib_unregister_client);
526
527/**
528 * ib_get_client_data - Get IB client context
529 * @device:Device to get context for
530 * @client:Client to get context for
531 *
532 * ib_get_client_data() returns client context set with
533 * ib_set_client_data().
534 */
535void *ib_get_client_data(struct ib_device *device, struct ib_client *client)
536{
537 struct ib_client_data *context;
538 void *ret = NULL;
539 unsigned long flags;
540
541 spin_lock_irqsave(&device->client_data_lock, flags);
542 list_for_each_entry(context, &device->client_data_list, list)
543 if (context->client == client) {
544 ret = context->data;
545 break;
546 }
547 spin_unlock_irqrestore(&device->client_data_lock, flags);
548
549 return ret;
550}
551EXPORT_SYMBOL(ib_get_client_data);
552
553/**
554 * ib_set_client_data - Set IB client context
555 * @device:Device to set context for
556 * @client:Client to set context for
557 * @data:Context to set
558 *
559 * ib_set_client_data() sets client context that can be retrieved with
560 * ib_get_client_data().
561 */
562void ib_set_client_data(struct ib_device *device, struct ib_client *client,
563 void *data)
564{
565 struct ib_client_data *context;
566 unsigned long flags;
567
568 spin_lock_irqsave(&device->client_data_lock, flags);
569 list_for_each_entry(context, &device->client_data_list, list)
570 if (context->client == client) {
571 context->data = data;
572 goto out;
573 }
574
575 pr_warn("No client context found for %s/%s\n",
576 device->name, client->name);
577
578out:
579 spin_unlock_irqrestore(&device->client_data_lock, flags);
580}
581EXPORT_SYMBOL(ib_set_client_data);
582
583/**
584 * ib_register_event_handler - Register an IB event handler
585 * @event_handler:Handler to register
586 *
587 * ib_register_event_handler() registers an event handler that will be
588 * called back when asynchronous IB events occur (as defined in
589 * chapter 11 of the InfiniBand Architecture Specification). This
590 * callback may occur in interrupt context.
591 */
592int ib_register_event_handler (struct ib_event_handler *event_handler)
593{
594 unsigned long flags;
595
596 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
597 list_add_tail(&event_handler->list,
598 &event_handler->device->event_handler_list);
599 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
600
601 return 0;
602}
603EXPORT_SYMBOL(ib_register_event_handler);
604
605/**
606 * ib_unregister_event_handler - Unregister an event handler
607 * @event_handler:Handler to unregister
608 *
609 * Unregister an event handler registered with
610 * ib_register_event_handler().
611 */
612int ib_unregister_event_handler(struct ib_event_handler *event_handler)
613{
614 unsigned long flags;
615
616 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
617 list_del(&event_handler->list);
618 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
619
620 return 0;
621}
622EXPORT_SYMBOL(ib_unregister_event_handler);
623
624/**
625 * ib_dispatch_event - Dispatch an asynchronous event
626 * @event:Event to dispatch
627 *
628 * Low-level drivers must call ib_dispatch_event() to dispatch the
629 * event to all registered event handlers when an asynchronous event
630 * occurs.
631 */
632void ib_dispatch_event(struct ib_event *event)
633{
634 unsigned long flags;
635 struct ib_event_handler *handler;
636
637 spin_lock_irqsave(&event->device->event_handler_lock, flags);
638
639 list_for_each_entry(handler, &event->device->event_handler_list, list)
640 handler->handler(handler, event);
641
642 spin_unlock_irqrestore(&event->device->event_handler_lock, flags);
643}
644EXPORT_SYMBOL(ib_dispatch_event);
645
646/**
647 * ib_query_port - Query IB port attributes
648 * @device:Device to query
649 * @port_num:Port number to query
650 * @port_attr:Port attributes
651 *
652 * ib_query_port() returns the attributes of a port through the
653 * @port_attr pointer.
654 */
655int ib_query_port(struct ib_device *device,
656 u8 port_num,
657 struct ib_port_attr *port_attr)
658{
659 union ib_gid gid;
660 int err;
661
662 if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
663 return -EINVAL;
664
665 memset(port_attr, 0, sizeof(*port_attr));
666 err = device->query_port(device, port_num, port_attr);
667 if (err || port_attr->subnet_prefix)
668 return err;
669
670 if (rdma_port_get_link_layer(device, port_num) != IB_LINK_LAYER_INFINIBAND)
671 return 0;
672
673 err = ib_query_gid(device, port_num, 0, &gid, NULL);
674 if (err)
675 return err;
676
677 port_attr->subnet_prefix = be64_to_cpu(gid.global.subnet_prefix);
678 return 0;
679}
680EXPORT_SYMBOL(ib_query_port);
681
682/**
683 * ib_query_gid - Get GID table entry
684 * @device:Device to query
685 * @port_num:Port number to query
686 * @index:GID table index to query
687 * @gid:Returned GID
688 * @attr: Returned GID attributes related to this GID index (only in RoCE).
689 * NULL means ignore.
690 *
691 * ib_query_gid() fetches the specified GID table entry.
692 */
693int ib_query_gid(struct ib_device *device,
694 u8 port_num, int index, union ib_gid *gid,
695 struct ib_gid_attr *attr)
696{
697 if (rdma_cap_roce_gid_table(device, port_num))
698 return ib_get_cached_gid(device, port_num, index, gid, attr);
699
700 if (attr)
701 return -EINVAL;
702
703 return device->query_gid(device, port_num, index, gid);
704}
705EXPORT_SYMBOL(ib_query_gid);
706
707/**
708 * ib_enum_roce_netdev - enumerate all RoCE ports
709 * @ib_dev : IB device we want to query
710 * @filter: Should we call the callback?
711 * @filter_cookie: Cookie passed to filter
712 * @cb: Callback to call for each found RoCE ports
713 * @cookie: Cookie passed back to the callback
714 *
715 * Enumerates all of the physical RoCE ports of ib_dev
716 * which are related to netdevice and calls callback() on each
717 * device for which filter() function returns non zero.
718 */
719void ib_enum_roce_netdev(struct ib_device *ib_dev,
720 roce_netdev_filter filter,
721 void *filter_cookie,
722 roce_netdev_callback cb,
723 void *cookie)
724{
725 u8 port;
726
727 for (port = rdma_start_port(ib_dev); port <= rdma_end_port(ib_dev);
728 port++)
729 if (rdma_protocol_roce(ib_dev, port)) {
730 struct net_device *idev = NULL;
731
732 if (ib_dev->get_netdev)
733 idev = ib_dev->get_netdev(ib_dev, port);
734
735 if (idev &&
736 idev->reg_state >= NETREG_UNREGISTERED) {
737 dev_put(idev);
738 idev = NULL;
739 }
740
741 if (filter(ib_dev, port, idev, filter_cookie))
742 cb(ib_dev, port, idev, cookie);
743
744 if (idev)
745 dev_put(idev);
746 }
747}
748
749/**
750 * ib_enum_all_roce_netdevs - enumerate all RoCE devices
751 * @filter: Should we call the callback?
752 * @filter_cookie: Cookie passed to filter
753 * @cb: Callback to call for each found RoCE ports
754 * @cookie: Cookie passed back to the callback
755 *
756 * Enumerates all RoCE devices' physical ports which are related
757 * to netdevices and calls callback() on each device for which
758 * filter() function returns non zero.
759 */
760void ib_enum_all_roce_netdevs(roce_netdev_filter filter,
761 void *filter_cookie,
762 roce_netdev_callback cb,
763 void *cookie)
764{
765 struct ib_device *dev;
766
767 down_read(&lists_rwsem);
768 list_for_each_entry(dev, &device_list, core_list)
769 ib_enum_roce_netdev(dev, filter, filter_cookie, cb, cookie);
770 up_read(&lists_rwsem);
771}
772
773/**
774 * ib_query_pkey - Get P_Key table entry
775 * @device:Device to query
776 * @port_num:Port number to query
777 * @index:P_Key table index to query
778 * @pkey:Returned P_Key
779 *
780 * ib_query_pkey() fetches the specified P_Key table entry.
781 */
782int ib_query_pkey(struct ib_device *device,
783 u8 port_num, u16 index, u16 *pkey)
784{
785 return device->query_pkey(device, port_num, index, pkey);
786}
787EXPORT_SYMBOL(ib_query_pkey);
788
789/**
790 * ib_modify_device - Change IB device attributes
791 * @device:Device to modify
792 * @device_modify_mask:Mask of attributes to change
793 * @device_modify:New attribute values
794 *
795 * ib_modify_device() changes a device's attributes as specified by
796 * the @device_modify_mask and @device_modify structure.
797 */
798int ib_modify_device(struct ib_device *device,
799 int device_modify_mask,
800 struct ib_device_modify *device_modify)
801{
802 if (!device->modify_device)
803 return -ENOSYS;
804
805 return device->modify_device(device, device_modify_mask,
806 device_modify);
807}
808EXPORT_SYMBOL(ib_modify_device);
809
810/**
811 * ib_modify_port - Modifies the attributes for the specified port.
812 * @device: The device to modify.
813 * @port_num: The number of the port to modify.
814 * @port_modify_mask: Mask used to specify which attributes of the port
815 * to change.
816 * @port_modify: New attribute values for the port.
817 *
818 * ib_modify_port() changes a port's attributes as specified by the
819 * @port_modify_mask and @port_modify structure.
820 */
821int ib_modify_port(struct ib_device *device,
822 u8 port_num, int port_modify_mask,
823 struct ib_port_modify *port_modify)
824{
825 if (!device->modify_port)
826 return -ENOSYS;
827
828 if (port_num < rdma_start_port(device) || port_num > rdma_end_port(device))
829 return -EINVAL;
830
831 return device->modify_port(device, port_num, port_modify_mask,
832 port_modify);
833}
834EXPORT_SYMBOL(ib_modify_port);
835
836/**
837 * ib_find_gid - Returns the port number and GID table index where
838 * a specified GID value occurs.
839 * @device: The device to query.
840 * @gid: The GID value to search for.
841 * @gid_type: Type of GID.
842 * @ndev: The ndev related to the GID to search for.
843 * @port_num: The port number of the device where the GID value was found.
844 * @index: The index into the GID table where the GID was found. This
845 * parameter may be NULL.
846 */
847int ib_find_gid(struct ib_device *device, union ib_gid *gid,
848 enum ib_gid_type gid_type, struct net_device *ndev,
849 u8 *port_num, u16 *index)
850{
851 union ib_gid tmp_gid;
852 int ret, port, i;
853
854 for (port = rdma_start_port(device); port <= rdma_end_port(device); ++port) {
855 if (rdma_cap_roce_gid_table(device, port)) {
856 if (!ib_find_cached_gid_by_port(device, gid, gid_type, port,
857 ndev, index)) {
858 *port_num = port;
859 return 0;
860 }
861 }
862
863 if (gid_type != IB_GID_TYPE_IB)
864 continue;
865
866 for (i = 0; i < device->port_immutable[port].gid_tbl_len; ++i) {
867 ret = ib_query_gid(device, port, i, &tmp_gid, NULL);
868 if (ret)
869 return ret;
870 if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
871 *port_num = port;
872 if (index)
873 *index = i;
874 return 0;
875 }
876 }
877 }
878
879 return -ENOENT;
880}
881EXPORT_SYMBOL(ib_find_gid);
882
883/**
884 * ib_find_pkey - Returns the PKey table index where a specified
885 * PKey value occurs.
886 * @device: The device to query.
887 * @port_num: The port number of the device to search for the PKey.
888 * @pkey: The PKey value to search for.
889 * @index: The index into the PKey table where the PKey was found.
890 */
891int ib_find_pkey(struct ib_device *device,
892 u8 port_num, u16 pkey, u16 *index)
893{
894 int ret, i;
895 u16 tmp_pkey;
896 int partial_ix = -1;
897
898 for (i = 0; i < device->port_immutable[port_num].pkey_tbl_len; ++i) {
899 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
900 if (ret)
901 return ret;
902 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
903 /* if there is full-member pkey take it.*/
904 if (tmp_pkey & 0x8000) {
905 *index = i;
906 return 0;
907 }
908 if (partial_ix < 0)
909 partial_ix = i;
910 }
911 }
912
913 /*no full-member, if exists take the limited*/
914 if (partial_ix >= 0) {
915 *index = partial_ix;
916 return 0;
917 }
918 return -ENOENT;
919}
920EXPORT_SYMBOL(ib_find_pkey);
921
922/**
923 * ib_get_net_dev_by_params() - Return the appropriate net_dev
924 * for a received CM request
925 * @dev: An RDMA device on which the request has been received.
926 * @port: Port number on the RDMA device.
927 * @pkey: The Pkey the request came on.
928 * @gid: A GID that the net_dev uses to communicate.
929 * @addr: Contains the IP address that the request specified as its
930 * destination.
931 */
932struct net_device *ib_get_net_dev_by_params(struct ib_device *dev,
933 u8 port,
934 u16 pkey,
935 const union ib_gid *gid,
936 const struct sockaddr *addr)
937{
938 struct net_device *net_dev = NULL;
939 struct ib_client_data *context;
940
941 if (!rdma_protocol_ib(dev, port))
942 return NULL;
943
944 down_read(&lists_rwsem);
945
946 list_for_each_entry(context, &dev->client_data_list, list) {
947 struct ib_client *client = context->client;
948
949 if (context->going_down)
950 continue;
951
952 if (client->get_net_dev_by_params) {
953 net_dev = client->get_net_dev_by_params(dev, port, pkey,
954 gid, addr,
955 context->data);
956 if (net_dev)
957 break;
958 }
959 }
960
961 up_read(&lists_rwsem);
962
963 return net_dev;
964}
965EXPORT_SYMBOL(ib_get_net_dev_by_params);
966
967static struct ibnl_client_cbs ibnl_ls_cb_table[] = {
968 [RDMA_NL_LS_OP_RESOLVE] = {
969 .dump = ib_nl_handle_resolve_resp,
970 .module = THIS_MODULE },
971 [RDMA_NL_LS_OP_SET_TIMEOUT] = {
972 .dump = ib_nl_handle_set_timeout,
973 .module = THIS_MODULE },
974 [RDMA_NL_LS_OP_IP_RESOLVE] = {
975 .dump = ib_nl_handle_ip_res_resp,
976 .module = THIS_MODULE },
977};
978
979static int ib_add_ibnl_clients(void)
980{
981 return ibnl_add_client(RDMA_NL_LS, ARRAY_SIZE(ibnl_ls_cb_table),
982 ibnl_ls_cb_table);
983}
984
985static void ib_remove_ibnl_clients(void)
986{
987 ibnl_remove_client(RDMA_NL_LS);
988}
989
990static int __init ib_core_init(void)
991{
992 int ret;
993
994 ib_wq = alloc_workqueue("infiniband", 0, 0);
995 if (!ib_wq)
996 return -ENOMEM;
997
998 ib_comp_wq = alloc_workqueue("ib-comp-wq",
999 WQ_UNBOUND | WQ_HIGHPRI | WQ_MEM_RECLAIM,
1000 WQ_UNBOUND_MAX_ACTIVE);
1001 if (!ib_comp_wq) {
1002 ret = -ENOMEM;
1003 goto err;
1004 }
1005
1006 ret = class_register(&ib_class);
1007 if (ret) {
1008 pr_warn("Couldn't create InfiniBand device class\n");
1009 goto err_comp;
1010 }
1011
1012 ret = ibnl_init();
1013 if (ret) {
1014 pr_warn("Couldn't init IB netlink interface\n");
1015 goto err_sysfs;
1016 }
1017
1018 ret = addr_init();
1019 if (ret) {
1020 pr_warn("Could't init IB address resolution\n");
1021 goto err_ibnl;
1022 }
1023
1024 ret = ib_mad_init();
1025 if (ret) {
1026 pr_warn("Couldn't init IB MAD\n");
1027 goto err_addr;
1028 }
1029
1030 ret = ib_sa_init();
1031 if (ret) {
1032 pr_warn("Couldn't init SA\n");
1033 goto err_mad;
1034 }
1035
1036 ret = ib_add_ibnl_clients();
1037 if (ret) {
1038 pr_warn("Couldn't register ibnl clients\n");
1039 goto err_sa;
1040 }
1041
1042 ib_cache_setup();
1043
1044 return 0;
1045
1046err_sa:
1047 ib_sa_cleanup();
1048err_mad:
1049 ib_mad_cleanup();
1050err_addr:
1051 addr_cleanup();
1052err_ibnl:
1053 ibnl_cleanup();
1054err_sysfs:
1055 class_unregister(&ib_class);
1056err_comp:
1057 destroy_workqueue(ib_comp_wq);
1058err:
1059 destroy_workqueue(ib_wq);
1060 return ret;
1061}
1062
1063static void __exit ib_core_cleanup(void)
1064{
1065 ib_cache_cleanup();
1066 ib_remove_ibnl_clients();
1067 ib_sa_cleanup();
1068 ib_mad_cleanup();
1069 addr_cleanup();
1070 ibnl_cleanup();
1071 class_unregister(&ib_class);
1072 destroy_workqueue(ib_comp_wq);
1073 /* Make sure that any pending umem accounting work is done. */
1074 destroy_workqueue(ib_wq);
1075}
1076
1077module_init(ib_core_init);
1078module_exit(ib_core_cleanup);