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#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/workqueue.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
55static LIST_HEAD(device_list);
56static LIST_HEAD(client_list);
57
58
59
60
61
62
63
64
65static DEFINE_MUTEX(device_mutex);
66
67static int ib_device_check_mandatory(struct ib_device *device)
68{
69#define IB_MANDATORY_FUNC(x) { offsetof(struct ib_device, x), #x }
70 static const struct {
71 size_t offset;
72 char *name;
73 } mandatory_table[] = {
74 IB_MANDATORY_FUNC(query_device),
75 IB_MANDATORY_FUNC(query_port),
76 IB_MANDATORY_FUNC(query_pkey),
77 IB_MANDATORY_FUNC(query_gid),
78 IB_MANDATORY_FUNC(alloc_pd),
79 IB_MANDATORY_FUNC(dealloc_pd),
80 IB_MANDATORY_FUNC(create_ah),
81 IB_MANDATORY_FUNC(destroy_ah),
82 IB_MANDATORY_FUNC(create_qp),
83 IB_MANDATORY_FUNC(modify_qp),
84 IB_MANDATORY_FUNC(destroy_qp),
85 IB_MANDATORY_FUNC(post_send),
86 IB_MANDATORY_FUNC(post_recv),
87 IB_MANDATORY_FUNC(create_cq),
88 IB_MANDATORY_FUNC(destroy_cq),
89 IB_MANDATORY_FUNC(poll_cq),
90 IB_MANDATORY_FUNC(req_notify_cq),
91 IB_MANDATORY_FUNC(get_dma_mr),
92 IB_MANDATORY_FUNC(dereg_mr)
93 };
94 int i;
95
96 for (i = 0; i < ARRAY_SIZE(mandatory_table); ++i) {
97 if (!*(void **) ((void *) device + mandatory_table[i].offset)) {
98 printk(KERN_WARNING "Device %s is missing mandatory function %s\n",
99 device->name, mandatory_table[i].name);
100 return -EINVAL;
101 }
102 }
103
104 return 0;
105}
106
107static struct ib_device *__ib_device_get_by_name(const char *name)
108{
109 struct ib_device *device;
110
111 list_for_each_entry(device, &device_list, core_list)
112 if (!strncmp(name, device->name, IB_DEVICE_NAME_MAX))
113 return device;
114
115 return NULL;
116}
117
118
119static int alloc_name(char *name)
120{
121 unsigned long *inuse;
122 char buf[IB_DEVICE_NAME_MAX];
123 struct ib_device *device;
124 int i;
125
126 inuse = (unsigned long *) get_zeroed_page(GFP_KERNEL);
127 if (!inuse)
128 return -ENOMEM;
129
130 list_for_each_entry(device, &device_list, core_list) {
131 if (!sscanf(device->name, name, &i))
132 continue;
133 if (i < 0 || i >= PAGE_SIZE * 8)
134 continue;
135 snprintf(buf, sizeof buf, name, i);
136 if (!strncmp(buf, device->name, IB_DEVICE_NAME_MAX))
137 set_bit(i, inuse);
138 }
139
140 i = find_first_zero_bit(inuse, PAGE_SIZE * 8);
141 free_page((unsigned long) inuse);
142 snprintf(buf, sizeof buf, name, i);
143
144 if (__ib_device_get_by_name(buf))
145 return -ENFILE;
146
147 strlcpy(name, buf, IB_DEVICE_NAME_MAX);
148 return 0;
149}
150
151static int start_port(struct ib_device *device)
152{
153 return (device->node_type == RDMA_NODE_IB_SWITCH) ? 0 : 1;
154}
155
156
157static int end_port(struct ib_device *device)
158{
159 return (device->node_type == RDMA_NODE_IB_SWITCH) ?
160 0 : device->phys_port_cnt;
161}
162
163
164
165
166
167
168
169
170
171
172
173struct ib_device *ib_alloc_device(size_t size)
174{
175 BUG_ON(size < sizeof (struct ib_device));
176
177 return kzalloc(size, GFP_KERNEL);
178}
179EXPORT_SYMBOL(ib_alloc_device);
180
181
182
183
184
185
186
187void ib_dealloc_device(struct ib_device *device)
188{
189 if (device->reg_state == IB_DEV_UNINITIALIZED) {
190 kfree(device);
191 return;
192 }
193
194 BUG_ON(device->reg_state != IB_DEV_UNREGISTERED);
195
196 kobject_put(&device->dev.kobj);
197}
198EXPORT_SYMBOL(ib_dealloc_device);
199
200static int add_client_context(struct ib_device *device, struct ib_client *client)
201{
202 struct ib_client_data *context;
203 unsigned long flags;
204
205 context = kmalloc(sizeof *context, GFP_KERNEL);
206 if (!context) {
207 printk(KERN_WARNING "Couldn't allocate client context for %s/%s\n",
208 device->name, client->name);
209 return -ENOMEM;
210 }
211
212 context->client = client;
213 context->data = NULL;
214
215 spin_lock_irqsave(&device->client_data_lock, flags);
216 list_add(&context->list, &device->client_data_list);
217 spin_unlock_irqrestore(&device->client_data_lock, flags);
218
219 return 0;
220}
221
222static int read_port_table_lengths(struct ib_device *device)
223{
224 struct ib_port_attr *tprops = NULL;
225 int num_ports, ret = -ENOMEM;
226 u8 port_index;
227
228 tprops = kmalloc(sizeof *tprops, GFP_KERNEL);
229 if (!tprops)
230 goto out;
231
232 num_ports = end_port(device) - start_port(device) + 1;
233
234 device->pkey_tbl_len = kmalloc(sizeof *device->pkey_tbl_len * num_ports,
235 GFP_KERNEL);
236 device->gid_tbl_len = kmalloc(sizeof *device->gid_tbl_len * num_ports,
237 GFP_KERNEL);
238 if (!device->pkey_tbl_len || !device->gid_tbl_len)
239 goto err;
240
241 for (port_index = 0; port_index < num_ports; ++port_index) {
242 ret = ib_query_port(device, port_index + start_port(device),
243 tprops);
244 if (ret)
245 goto err;
246 device->pkey_tbl_len[port_index] = tprops->pkey_tbl_len;
247 device->gid_tbl_len[port_index] = tprops->gid_tbl_len;
248 }
249
250 ret = 0;
251 goto out;
252
253err:
254 kfree(device->gid_tbl_len);
255 kfree(device->pkey_tbl_len);
256out:
257 kfree(tprops);
258 return ret;
259}
260
261
262
263
264
265
266
267
268
269
270int ib_register_device(struct ib_device *device)
271{
272 int ret;
273
274 mutex_lock(&device_mutex);
275
276 if (strchr(device->name, '%')) {
277 ret = alloc_name(device->name);
278 if (ret)
279 goto out;
280 }
281
282 if (ib_device_check_mandatory(device)) {
283 ret = -EINVAL;
284 goto out;
285 }
286
287 INIT_LIST_HEAD(&device->event_handler_list);
288 INIT_LIST_HEAD(&device->client_data_list);
289 spin_lock_init(&device->event_handler_lock);
290 spin_lock_init(&device->client_data_lock);
291
292 ret = read_port_table_lengths(device);
293 if (ret) {
294 printk(KERN_WARNING "Couldn't create table lengths cache for device %s\n",
295 device->name);
296 goto out;
297 }
298
299 ret = ib_device_register_sysfs(device);
300 if (ret) {
301 printk(KERN_WARNING "Couldn't register device %s with driver model\n",
302 device->name);
303 kfree(device->gid_tbl_len);
304 kfree(device->pkey_tbl_len);
305 goto out;
306 }
307
308 list_add_tail(&device->core_list, &device_list);
309
310 device->reg_state = IB_DEV_REGISTERED;
311
312 {
313 struct ib_client *client;
314
315 list_for_each_entry(client, &client_list, list)
316 if (client->add && !add_client_context(device, client))
317 client->add(device);
318 }
319
320 out:
321 mutex_unlock(&device_mutex);
322 return ret;
323}
324EXPORT_SYMBOL(ib_register_device);
325
326
327
328
329
330
331
332void ib_unregister_device(struct ib_device *device)
333{
334 struct ib_client *client;
335 struct ib_client_data *context, *tmp;
336 unsigned long flags;
337
338 mutex_lock(&device_mutex);
339
340 list_for_each_entry_reverse(client, &client_list, list)
341 if (client->remove)
342 client->remove(device);
343
344 list_del(&device->core_list);
345
346 kfree(device->gid_tbl_len);
347 kfree(device->pkey_tbl_len);
348
349 mutex_unlock(&device_mutex);
350
351 ib_device_unregister_sysfs(device);
352
353 spin_lock_irqsave(&device->client_data_lock, flags);
354 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
355 kfree(context);
356 spin_unlock_irqrestore(&device->client_data_lock, flags);
357
358 device->reg_state = IB_DEV_UNREGISTERED;
359}
360EXPORT_SYMBOL(ib_unregister_device);
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375int ib_register_client(struct ib_client *client)
376{
377 struct ib_device *device;
378
379 mutex_lock(&device_mutex);
380
381 list_add_tail(&client->list, &client_list);
382 list_for_each_entry(device, &device_list, core_list)
383 if (client->add && !add_client_context(device, client))
384 client->add(device);
385
386 mutex_unlock(&device_mutex);
387
388 return 0;
389}
390EXPORT_SYMBOL(ib_register_client);
391
392
393
394
395
396
397
398
399
400void ib_unregister_client(struct ib_client *client)
401{
402 struct ib_client_data *context, *tmp;
403 struct ib_device *device;
404 unsigned long flags;
405
406 mutex_lock(&device_mutex);
407
408 list_for_each_entry(device, &device_list, core_list) {
409 if (client->remove)
410 client->remove(device);
411
412 spin_lock_irqsave(&device->client_data_lock, flags);
413 list_for_each_entry_safe(context, tmp, &device->client_data_list, list)
414 if (context->client == client) {
415 list_del(&context->list);
416 kfree(context);
417 }
418 spin_unlock_irqrestore(&device->client_data_lock, flags);
419 }
420 list_del(&client->list);
421
422 mutex_unlock(&device_mutex);
423}
424EXPORT_SYMBOL(ib_unregister_client);
425
426
427
428
429
430
431
432
433
434void *ib_get_client_data(struct ib_device *device, struct ib_client *client)
435{
436 struct ib_client_data *context;
437 void *ret = NULL;
438 unsigned long flags;
439
440 spin_lock_irqsave(&device->client_data_lock, flags);
441 list_for_each_entry(context, &device->client_data_list, list)
442 if (context->client == client) {
443 ret = context->data;
444 break;
445 }
446 spin_unlock_irqrestore(&device->client_data_lock, flags);
447
448 return ret;
449}
450EXPORT_SYMBOL(ib_get_client_data);
451
452
453
454
455
456
457
458
459
460
461void ib_set_client_data(struct ib_device *device, struct ib_client *client,
462 void *data)
463{
464 struct ib_client_data *context;
465 unsigned long flags;
466
467 spin_lock_irqsave(&device->client_data_lock, flags);
468 list_for_each_entry(context, &device->client_data_list, list)
469 if (context->client == client) {
470 context->data = data;
471 goto out;
472 }
473
474 printk(KERN_WARNING "No client context found for %s/%s\n",
475 device->name, client->name);
476
477out:
478 spin_unlock_irqrestore(&device->client_data_lock, flags);
479}
480EXPORT_SYMBOL(ib_set_client_data);
481
482
483
484
485
486
487
488
489
490
491int ib_register_event_handler (struct ib_event_handler *event_handler)
492{
493 unsigned long flags;
494
495 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
496 list_add_tail(&event_handler->list,
497 &event_handler->device->event_handler_list);
498 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
499
500 return 0;
501}
502EXPORT_SYMBOL(ib_register_event_handler);
503
504
505
506
507
508
509
510
511int ib_unregister_event_handler(struct ib_event_handler *event_handler)
512{
513 unsigned long flags;
514
515 spin_lock_irqsave(&event_handler->device->event_handler_lock, flags);
516 list_del(&event_handler->list);
517 spin_unlock_irqrestore(&event_handler->device->event_handler_lock, flags);
518
519 return 0;
520}
521EXPORT_SYMBOL(ib_unregister_event_handler);
522
523
524
525
526
527
528
529
530
531void ib_dispatch_event(struct ib_event *event)
532{
533 unsigned long flags;
534 struct ib_event_handler *handler;
535
536 spin_lock_irqsave(&event->device->event_handler_lock, flags);
537
538 list_for_each_entry(handler, &event->device->event_handler_list, list)
539 handler->handler(handler, event);
540
541 spin_unlock_irqrestore(&event->device->event_handler_lock, flags);
542}
543EXPORT_SYMBOL(ib_dispatch_event);
544
545
546
547
548
549
550
551
552
553int ib_query_device(struct ib_device *device,
554 struct ib_device_attr *device_attr)
555{
556 return device->query_device(device, device_attr);
557}
558EXPORT_SYMBOL(ib_query_device);
559
560
561
562
563
564
565
566
567
568
569int ib_query_port(struct ib_device *device,
570 u8 port_num,
571 struct ib_port_attr *port_attr)
572{
573 if (port_num < start_port(device) || port_num > end_port(device))
574 return -EINVAL;
575
576 return device->query_port(device, port_num, port_attr);
577}
578EXPORT_SYMBOL(ib_query_port);
579
580
581
582
583
584
585
586
587
588
589int ib_query_gid(struct ib_device *device,
590 u8 port_num, int index, union ib_gid *gid)
591{
592 return device->query_gid(device, port_num, index, gid);
593}
594EXPORT_SYMBOL(ib_query_gid);
595
596
597
598
599
600
601
602
603
604
605int ib_query_pkey(struct ib_device *device,
606 u8 port_num, u16 index, u16 *pkey)
607{
608 return device->query_pkey(device, port_num, index, pkey);
609}
610EXPORT_SYMBOL(ib_query_pkey);
611
612
613
614
615
616
617
618
619
620
621int ib_modify_device(struct ib_device *device,
622 int device_modify_mask,
623 struct ib_device_modify *device_modify)
624{
625 return device->modify_device(device, device_modify_mask,
626 device_modify);
627}
628EXPORT_SYMBOL(ib_modify_device);
629
630
631
632
633
634
635
636
637
638
639
640
641int ib_modify_port(struct ib_device *device,
642 u8 port_num, int port_modify_mask,
643 struct ib_port_modify *port_modify)
644{
645 if (port_num < start_port(device) || port_num > end_port(device))
646 return -EINVAL;
647
648 return device->modify_port(device, port_num, port_modify_mask,
649 port_modify);
650}
651EXPORT_SYMBOL(ib_modify_port);
652
653
654
655
656
657
658
659
660
661
662int ib_find_gid(struct ib_device *device, union ib_gid *gid,
663 u8 *port_num, u16 *index)
664{
665 union ib_gid tmp_gid;
666 int ret, port, i;
667
668 for (port = start_port(device); port <= end_port(device); ++port) {
669 for (i = 0; i < device->gid_tbl_len[port - start_port(device)]; ++i) {
670 ret = ib_query_gid(device, port, i, &tmp_gid);
671 if (ret)
672 return ret;
673 if (!memcmp(&tmp_gid, gid, sizeof *gid)) {
674 *port_num = port;
675 if (index)
676 *index = i;
677 return 0;
678 }
679 }
680 }
681
682 return -ENOENT;
683}
684EXPORT_SYMBOL(ib_find_gid);
685
686
687
688
689
690
691
692
693
694int ib_find_pkey(struct ib_device *device,
695 u8 port_num, u16 pkey, u16 *index)
696{
697 int ret, i;
698 u16 tmp_pkey;
699
700 for (i = 0; i < device->pkey_tbl_len[port_num - start_port(device)]; ++i) {
701 ret = ib_query_pkey(device, port_num, i, &tmp_pkey);
702 if (ret)
703 return ret;
704
705 if ((pkey & 0x7fff) == (tmp_pkey & 0x7fff)) {
706 *index = i;
707 return 0;
708 }
709 }
710
711 return -ENOENT;
712}
713EXPORT_SYMBOL(ib_find_pkey);
714
715static int __init ib_core_init(void)
716{
717 int ret;
718
719 ret = ib_sysfs_setup();
720 if (ret)
721 printk(KERN_WARNING "Couldn't create InfiniBand device class\n");
722
723 ret = ib_cache_setup();
724 if (ret) {
725 printk(KERN_WARNING "Couldn't set up InfiniBand P_Key/GID cache\n");
726 ib_sysfs_cleanup();
727 }
728
729 return ret;
730}
731
732static void __exit ib_core_cleanup(void)
733{
734 ib_cache_cleanup();
735 ib_sysfs_cleanup();
736
737 flush_scheduled_work();
738}
739
740module_init(ib_core_init);
741module_exit(ib_core_cleanup);
742