2 * Copyright (c) 2006 Intel Corporation. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 #include <linux/completion.h>
34 #include <linux/dma-mapping.h>
35 #include <linux/err.h>
36 #include <linux/interrupt.h>
37 #include <linux/export.h>
38 #include <linux/slab.h>
39 #include <linux/bitops.h>
40 #include <linux/random.h>
42 #include <rdma/ib_cache.h>
45 static void mcast_add_one(struct ib_device
*device
);
46 static void mcast_remove_one(struct ib_device
*device
, void *client_data
);
48 static struct ib_client mcast_client
= {
49 .name
= "ib_multicast",
51 .remove
= mcast_remove_one
54 static struct ib_sa_client sa_client
;
55 static struct workqueue_struct
*mcast_wq
;
56 static union ib_gid mgid0
;
61 struct mcast_device
*dev
;
65 struct completion comp
;
70 struct ib_device
*device
;
71 struct ib_event_handler event_handler
;
74 struct mcast_port port
[0];
83 enum mcast_group_state
{
91 MCAST_INVALID_PKEY_INDEX
= 0xFFFF
97 struct ib_sa_mcmember_rec rec
;
99 struct mcast_port
*port
;
101 struct work_struct work
;
102 struct list_head pending_list
;
103 struct list_head active_list
;
104 struct mcast_member
*last_join
;
105 int members
[NUM_JOIN_MEMBERSHIP_TYPES
];
107 enum mcast_group_state state
;
108 struct ib_sa_query
*query
;
115 struct mcast_member
{
116 struct ib_sa_multicast multicast
;
117 struct ib_sa_client
*client
;
118 struct mcast_group
*group
;
119 struct list_head list
;
120 enum mcast_state state
;
122 struct completion comp
;
125 static void join_handler(int status
, struct ib_sa_mcmember_rec
*rec
,
127 static void leave_handler(int status
, struct ib_sa_mcmember_rec
*rec
,
130 static struct mcast_group
*mcast_find(struct mcast_port
*port
,
133 struct rb_node
*node
= port
->table
.rb_node
;
134 struct mcast_group
*group
;
138 group
= rb_entry(node
, struct mcast_group
, node
);
139 ret
= memcmp(mgid
->raw
, group
->rec
.mgid
.raw
, sizeof *mgid
);
144 node
= node
->rb_left
;
146 node
= node
->rb_right
;
151 static struct mcast_group
*mcast_insert(struct mcast_port
*port
,
152 struct mcast_group
*group
,
153 int allow_duplicates
)
155 struct rb_node
**link
= &port
->table
.rb_node
;
156 struct rb_node
*parent
= NULL
;
157 struct mcast_group
*cur_group
;
162 cur_group
= rb_entry(parent
, struct mcast_group
, node
);
164 ret
= memcmp(group
->rec
.mgid
.raw
, cur_group
->rec
.mgid
.raw
,
165 sizeof group
->rec
.mgid
);
167 link
= &(*link
)->rb_left
;
169 link
= &(*link
)->rb_right
;
170 else if (allow_duplicates
)
171 link
= &(*link
)->rb_left
;
175 rb_link_node(&group
->node
, parent
, link
);
176 rb_insert_color(&group
->node
, &port
->table
);
180 static void deref_port(struct mcast_port
*port
)
182 if (atomic_dec_and_test(&port
->refcount
))
183 complete(&port
->comp
);
186 static void release_group(struct mcast_group
*group
)
188 struct mcast_port
*port
= group
->port
;
191 spin_lock_irqsave(&port
->lock
, flags
);
192 if (atomic_dec_and_test(&group
->refcount
)) {
193 rb_erase(&group
->node
, &port
->table
);
194 spin_unlock_irqrestore(&port
->lock
, flags
);
198 spin_unlock_irqrestore(&port
->lock
, flags
);
201 static void deref_member(struct mcast_member
*member
)
203 if (atomic_dec_and_test(&member
->refcount
))
204 complete(&member
->comp
);
207 static void queue_join(struct mcast_member
*member
)
209 struct mcast_group
*group
= member
->group
;
212 spin_lock_irqsave(&group
->lock
, flags
);
213 list_add_tail(&member
->list
, &group
->pending_list
);
214 if (group
->state
== MCAST_IDLE
) {
215 group
->state
= MCAST_BUSY
;
216 atomic_inc(&group
->refcount
);
217 queue_work(mcast_wq
, &group
->work
);
219 spin_unlock_irqrestore(&group
->lock
, flags
);
223 * A multicast group has four types of members: full member, non member,
224 * sendonly non member and sendonly full member.
225 * We need to keep track of the number of members of each
226 * type based on their join state. Adjust the number of members the belong to
227 * the specified join states.
229 static void adjust_membership(struct mcast_group
*group
, u8 join_state
, int inc
)
233 for (i
= 0; i
< NUM_JOIN_MEMBERSHIP_TYPES
; i
++, join_state
>>= 1)
234 if (join_state
& 0x1)
235 group
->members
[i
] += inc
;
239 * If a multicast group has zero members left for a particular join state, but
240 * the group is still a member with the SA, we need to leave that join state.
241 * Determine which join states we still belong to, but that do not have any
244 static u8
get_leave_state(struct mcast_group
*group
)
249 for (i
= 0; i
< NUM_JOIN_MEMBERSHIP_TYPES
; i
++)
250 if (!group
->members
[i
])
251 leave_state
|= (0x1 << i
);
253 return leave_state
& group
->rec
.join_state
;
256 static int check_selector(ib_sa_comp_mask comp_mask
,
257 ib_sa_comp_mask selector_mask
,
258 ib_sa_comp_mask value_mask
,
259 u8 selector
, u8 src_value
, u8 dst_value
)
263 if (!(comp_mask
& selector_mask
) || !(comp_mask
& value_mask
))
268 err
= (src_value
<= dst_value
);
271 err
= (src_value
>= dst_value
);
274 err
= (src_value
!= dst_value
);
284 static int cmp_rec(struct ib_sa_mcmember_rec
*src
,
285 struct ib_sa_mcmember_rec
*dst
, ib_sa_comp_mask comp_mask
)
287 /* MGID must already match */
289 if (comp_mask
& IB_SA_MCMEMBER_REC_PORT_GID
&&
290 memcmp(&src
->port_gid
, &dst
->port_gid
, sizeof src
->port_gid
))
292 if (comp_mask
& IB_SA_MCMEMBER_REC_QKEY
&& src
->qkey
!= dst
->qkey
)
294 if (comp_mask
& IB_SA_MCMEMBER_REC_MLID
&& src
->mlid
!= dst
->mlid
)
296 if (check_selector(comp_mask
, IB_SA_MCMEMBER_REC_MTU_SELECTOR
,
297 IB_SA_MCMEMBER_REC_MTU
, dst
->mtu_selector
,
300 if (comp_mask
& IB_SA_MCMEMBER_REC_TRAFFIC_CLASS
&&
301 src
->traffic_class
!= dst
->traffic_class
)
303 if (comp_mask
& IB_SA_MCMEMBER_REC_PKEY
&& src
->pkey
!= dst
->pkey
)
305 if (check_selector(comp_mask
, IB_SA_MCMEMBER_REC_RATE_SELECTOR
,
306 IB_SA_MCMEMBER_REC_RATE
, dst
->rate_selector
,
307 src
->rate
, dst
->rate
))
309 if (check_selector(comp_mask
,
310 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR
,
311 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME
,
312 dst
->packet_life_time_selector
,
313 src
->packet_life_time
, dst
->packet_life_time
))
315 if (comp_mask
& IB_SA_MCMEMBER_REC_SL
&& src
->sl
!= dst
->sl
)
317 if (comp_mask
& IB_SA_MCMEMBER_REC_FLOW_LABEL
&&
318 src
->flow_label
!= dst
->flow_label
)
320 if (comp_mask
& IB_SA_MCMEMBER_REC_HOP_LIMIT
&&
321 src
->hop_limit
!= dst
->hop_limit
)
323 if (comp_mask
& IB_SA_MCMEMBER_REC_SCOPE
&& src
->scope
!= dst
->scope
)
326 /* join_state checked separately, proxy_join ignored */
331 static int send_join(struct mcast_group
*group
, struct mcast_member
*member
)
333 struct mcast_port
*port
= group
->port
;
336 group
->last_join
= member
;
337 ret
= ib_sa_mcmember_rec_query(&sa_client
, port
->dev
->device
,
338 port
->port_num
, IB_MGMT_METHOD_SET
,
339 &member
->multicast
.rec
,
340 member
->multicast
.comp_mask
,
341 3000, GFP_KERNEL
, join_handler
, group
,
344 group
->query_id
= ret
;
350 static int send_leave(struct mcast_group
*group
, u8 leave_state
)
352 struct mcast_port
*port
= group
->port
;
353 struct ib_sa_mcmember_rec rec
;
357 rec
.join_state
= leave_state
;
358 group
->leave_state
= leave_state
;
360 ret
= ib_sa_mcmember_rec_query(&sa_client
, port
->dev
->device
,
361 port
->port_num
, IB_SA_METHOD_DELETE
, &rec
,
362 IB_SA_MCMEMBER_REC_MGID
|
363 IB_SA_MCMEMBER_REC_PORT_GID
|
364 IB_SA_MCMEMBER_REC_JOIN_STATE
,
365 3000, GFP_KERNEL
, leave_handler
,
366 group
, &group
->query
);
368 group
->query_id
= ret
;
374 static void join_group(struct mcast_group
*group
, struct mcast_member
*member
,
377 member
->state
= MCAST_MEMBER
;
378 adjust_membership(group
, join_state
, 1);
379 group
->rec
.join_state
|= join_state
;
380 member
->multicast
.rec
= group
->rec
;
381 member
->multicast
.rec
.join_state
= join_state
;
382 list_move(&member
->list
, &group
->active_list
);
385 static int fail_join(struct mcast_group
*group
, struct mcast_member
*member
,
388 spin_lock_irq(&group
->lock
);
389 list_del_init(&member
->list
);
390 spin_unlock_irq(&group
->lock
);
391 return member
->multicast
.callback(status
, &member
->multicast
);
394 static void process_group_error(struct mcast_group
*group
)
396 struct mcast_member
*member
;
400 if (group
->state
== MCAST_PKEY_EVENT
)
401 ret
= ib_find_pkey(group
->port
->dev
->device
,
402 group
->port
->port_num
,
403 be16_to_cpu(group
->rec
.pkey
), &pkey_index
);
405 spin_lock_irq(&group
->lock
);
406 if (group
->state
== MCAST_PKEY_EVENT
&& !ret
&&
407 group
->pkey_index
== pkey_index
)
410 while (!list_empty(&group
->active_list
)) {
411 member
= list_entry(group
->active_list
.next
,
412 struct mcast_member
, list
);
413 atomic_inc(&member
->refcount
);
414 list_del_init(&member
->list
);
415 adjust_membership(group
, member
->multicast
.rec
.join_state
, -1);
416 member
->state
= MCAST_ERROR
;
417 spin_unlock_irq(&group
->lock
);
419 ret
= member
->multicast
.callback(-ENETRESET
,
421 deref_member(member
);
423 ib_sa_free_multicast(&member
->multicast
);
424 spin_lock_irq(&group
->lock
);
427 group
->rec
.join_state
= 0;
429 group
->state
= MCAST_BUSY
;
430 spin_unlock_irq(&group
->lock
);
433 static void mcast_work_handler(struct work_struct
*work
)
435 struct mcast_group
*group
;
436 struct mcast_member
*member
;
437 struct ib_sa_multicast
*multicast
;
441 group
= container_of(work
, typeof(*group
), work
);
443 spin_lock_irq(&group
->lock
);
444 while (!list_empty(&group
->pending_list
) ||
445 (group
->state
!= MCAST_BUSY
)) {
447 if (group
->state
!= MCAST_BUSY
) {
448 spin_unlock_irq(&group
->lock
);
449 process_group_error(group
);
453 member
= list_entry(group
->pending_list
.next
,
454 struct mcast_member
, list
);
455 multicast
= &member
->multicast
;
456 join_state
= multicast
->rec
.join_state
;
457 atomic_inc(&member
->refcount
);
459 if (join_state
== (group
->rec
.join_state
& join_state
)) {
460 status
= cmp_rec(&group
->rec
, &multicast
->rec
,
461 multicast
->comp_mask
);
463 join_group(group
, member
, join_state
);
465 list_del_init(&member
->list
);
466 spin_unlock_irq(&group
->lock
);
467 ret
= multicast
->callback(status
, multicast
);
469 spin_unlock_irq(&group
->lock
);
470 status
= send_join(group
, member
);
472 deref_member(member
);
475 ret
= fail_join(group
, member
, status
);
478 deref_member(member
);
480 ib_sa_free_multicast(&member
->multicast
);
481 spin_lock_irq(&group
->lock
);
484 join_state
= get_leave_state(group
);
486 group
->rec
.join_state
&= ~join_state
;
487 spin_unlock_irq(&group
->lock
);
488 if (send_leave(group
, join_state
))
491 group
->state
= MCAST_IDLE
;
492 spin_unlock_irq(&group
->lock
);
493 release_group(group
);
498 * Fail a join request if it is still active - at the head of the pending queue.
500 static void process_join_error(struct mcast_group
*group
, int status
)
502 struct mcast_member
*member
;
505 spin_lock_irq(&group
->lock
);
506 member
= list_entry(group
->pending_list
.next
,
507 struct mcast_member
, list
);
508 if (group
->last_join
== member
) {
509 atomic_inc(&member
->refcount
);
510 list_del_init(&member
->list
);
511 spin_unlock_irq(&group
->lock
);
512 ret
= member
->multicast
.callback(status
, &member
->multicast
);
513 deref_member(member
);
515 ib_sa_free_multicast(&member
->multicast
);
517 spin_unlock_irq(&group
->lock
);
520 static void join_handler(int status
, struct ib_sa_mcmember_rec
*rec
,
523 struct mcast_group
*group
= context
;
524 u16 pkey_index
= MCAST_INVALID_PKEY_INDEX
;
527 process_join_error(group
, status
);
529 int mgids_changed
, is_mgid0
;
530 ib_find_pkey(group
->port
->dev
->device
, group
->port
->port_num
,
531 be16_to_cpu(rec
->pkey
), &pkey_index
);
533 spin_lock_irq(&group
->port
->lock
);
534 if (group
->state
== MCAST_BUSY
&&
535 group
->pkey_index
== MCAST_INVALID_PKEY_INDEX
)
536 group
->pkey_index
= pkey_index
;
537 mgids_changed
= memcmp(&rec
->mgid
, &group
->rec
.mgid
,
538 sizeof(group
->rec
.mgid
));
541 rb_erase(&group
->node
, &group
->port
->table
);
542 is_mgid0
= !memcmp(&mgid0
, &group
->rec
.mgid
,
544 mcast_insert(group
->port
, group
, is_mgid0
);
546 spin_unlock_irq(&group
->port
->lock
);
548 mcast_work_handler(&group
->work
);
551 static void leave_handler(int status
, struct ib_sa_mcmember_rec
*rec
,
554 struct mcast_group
*group
= context
;
556 if (status
&& group
->retries
> 0 &&
557 !send_leave(group
, group
->leave_state
))
560 mcast_work_handler(&group
->work
);
563 static struct mcast_group
*acquire_group(struct mcast_port
*port
,
564 union ib_gid
*mgid
, gfp_t gfp_mask
)
566 struct mcast_group
*group
, *cur_group
;
570 is_mgid0
= !memcmp(&mgid0
, mgid
, sizeof mgid0
);
572 spin_lock_irqsave(&port
->lock
, flags
);
573 group
= mcast_find(port
, mgid
);
576 spin_unlock_irqrestore(&port
->lock
, flags
);
579 group
= kzalloc(sizeof *group
, gfp_mask
);
585 group
->rec
.mgid
= *mgid
;
586 group
->pkey_index
= MCAST_INVALID_PKEY_INDEX
;
587 INIT_LIST_HEAD(&group
->pending_list
);
588 INIT_LIST_HEAD(&group
->active_list
);
589 INIT_WORK(&group
->work
, mcast_work_handler
);
590 spin_lock_init(&group
->lock
);
592 spin_lock_irqsave(&port
->lock
, flags
);
593 cur_group
= mcast_insert(port
, group
, is_mgid0
);
598 atomic_inc(&port
->refcount
);
600 atomic_inc(&group
->refcount
);
601 spin_unlock_irqrestore(&port
->lock
, flags
);
606 * We serialize all join requests to a single group to make our lives much
607 * easier. Otherwise, two users could try to join the same group
608 * simultaneously, with different configurations, one could leave while the
609 * join is in progress, etc., which makes locking around error recovery
612 struct ib_sa_multicast
*
613 ib_sa_join_multicast(struct ib_sa_client
*client
,
614 struct ib_device
*device
, u8 port_num
,
615 struct ib_sa_mcmember_rec
*rec
,
616 ib_sa_comp_mask comp_mask
, gfp_t gfp_mask
,
617 int (*callback
)(int status
,
618 struct ib_sa_multicast
*multicast
),
621 struct mcast_device
*dev
;
622 struct mcast_member
*member
;
623 struct ib_sa_multicast
*multicast
;
626 dev
= ib_get_client_data(device
, &mcast_client
);
628 return ERR_PTR(-ENODEV
);
630 member
= kmalloc(sizeof *member
, gfp_mask
);
632 return ERR_PTR(-ENOMEM
);
634 ib_sa_client_get(client
);
635 member
->client
= client
;
636 member
->multicast
.rec
= *rec
;
637 member
->multicast
.comp_mask
= comp_mask
;
638 member
->multicast
.callback
= callback
;
639 member
->multicast
.context
= context
;
640 init_completion(&member
->comp
);
641 atomic_set(&member
->refcount
, 1);
642 member
->state
= MCAST_JOINING
;
644 member
->group
= acquire_group(&dev
->port
[port_num
- dev
->start_port
],
645 &rec
->mgid
, gfp_mask
);
646 if (!member
->group
) {
652 * The user will get the multicast structure in their callback. They
653 * could then free the multicast structure before we can return from
654 * this routine. So we save the pointer to return before queuing
657 multicast
= &member
->multicast
;
662 ib_sa_client_put(client
);
666 EXPORT_SYMBOL(ib_sa_join_multicast
);
668 void ib_sa_free_multicast(struct ib_sa_multicast
*multicast
)
670 struct mcast_member
*member
;
671 struct mcast_group
*group
;
673 member
= container_of(multicast
, struct mcast_member
, multicast
);
674 group
= member
->group
;
676 spin_lock_irq(&group
->lock
);
677 if (member
->state
== MCAST_MEMBER
)
678 adjust_membership(group
, multicast
->rec
.join_state
, -1);
680 list_del_init(&member
->list
);
682 if (group
->state
== MCAST_IDLE
) {
683 group
->state
= MCAST_BUSY
;
684 spin_unlock_irq(&group
->lock
);
685 /* Continue to hold reference on group until callback */
686 queue_work(mcast_wq
, &group
->work
);
688 spin_unlock_irq(&group
->lock
);
689 release_group(group
);
692 deref_member(member
);
693 wait_for_completion(&member
->comp
);
694 ib_sa_client_put(member
->client
);
697 EXPORT_SYMBOL(ib_sa_free_multicast
);
699 int ib_sa_get_mcmember_rec(struct ib_device
*device
, u8 port_num
,
700 union ib_gid
*mgid
, struct ib_sa_mcmember_rec
*rec
)
702 struct mcast_device
*dev
;
703 struct mcast_port
*port
;
704 struct mcast_group
*group
;
708 dev
= ib_get_client_data(device
, &mcast_client
);
712 port
= &dev
->port
[port_num
- dev
->start_port
];
713 spin_lock_irqsave(&port
->lock
, flags
);
714 group
= mcast_find(port
, mgid
);
718 ret
= -EADDRNOTAVAIL
;
719 spin_unlock_irqrestore(&port
->lock
, flags
);
723 EXPORT_SYMBOL(ib_sa_get_mcmember_rec
);
725 int ib_init_ah_from_mcmember(struct ib_device
*device
, u8 port_num
,
726 struct ib_sa_mcmember_rec
*rec
,
727 struct net_device
*ndev
,
728 enum ib_gid_type gid_type
,
729 struct ib_ah_attr
*ah_attr
)
735 if (rdma_protocol_roce(device
, port_num
)) {
736 ret
= ib_find_cached_gid_by_port(device
, &rec
->port_gid
,
740 } else if (rdma_protocol_ib(device
, port_num
)) {
741 ret
= ib_find_cached_gid(device
, &rec
->port_gid
,
742 IB_GID_TYPE_IB
, NULL
, &p
,
751 memset(ah_attr
, 0, sizeof *ah_attr
);
752 ah_attr
->dlid
= be16_to_cpu(rec
->mlid
);
753 ah_attr
->sl
= rec
->sl
;
754 ah_attr
->port_num
= port_num
;
755 ah_attr
->static_rate
= rec
->rate
;
757 ah_attr
->ah_flags
= IB_AH_GRH
;
758 ah_attr
->grh
.dgid
= rec
->mgid
;
760 ah_attr
->grh
.sgid_index
= (u8
) gid_index
;
761 ah_attr
->grh
.flow_label
= be32_to_cpu(rec
->flow_label
);
762 ah_attr
->grh
.hop_limit
= rec
->hop_limit
;
763 ah_attr
->grh
.traffic_class
= rec
->traffic_class
;
767 EXPORT_SYMBOL(ib_init_ah_from_mcmember
);
769 static void mcast_groups_event(struct mcast_port
*port
,
770 enum mcast_group_state state
)
772 struct mcast_group
*group
;
773 struct rb_node
*node
;
776 spin_lock_irqsave(&port
->lock
, flags
);
777 for (node
= rb_first(&port
->table
); node
; node
= rb_next(node
)) {
778 group
= rb_entry(node
, struct mcast_group
, node
);
779 spin_lock(&group
->lock
);
780 if (group
->state
== MCAST_IDLE
) {
781 atomic_inc(&group
->refcount
);
782 queue_work(mcast_wq
, &group
->work
);
784 if (group
->state
!= MCAST_GROUP_ERROR
)
785 group
->state
= state
;
786 spin_unlock(&group
->lock
);
788 spin_unlock_irqrestore(&port
->lock
, flags
);
791 static void mcast_event_handler(struct ib_event_handler
*handler
,
792 struct ib_event
*event
)
794 struct mcast_device
*dev
;
797 dev
= container_of(handler
, struct mcast_device
, event_handler
);
798 if (!rdma_cap_ib_mcast(dev
->device
, event
->element
.port_num
))
801 index
= event
->element
.port_num
- dev
->start_port
;
803 switch (event
->event
) {
804 case IB_EVENT_PORT_ERR
:
805 case IB_EVENT_LID_CHANGE
:
806 case IB_EVENT_SM_CHANGE
:
807 case IB_EVENT_CLIENT_REREGISTER
:
808 mcast_groups_event(&dev
->port
[index
], MCAST_GROUP_ERROR
);
810 case IB_EVENT_PKEY_CHANGE
:
811 mcast_groups_event(&dev
->port
[index
], MCAST_PKEY_EVENT
);
818 static void mcast_add_one(struct ib_device
*device
)
820 struct mcast_device
*dev
;
821 struct mcast_port
*port
;
825 dev
= kmalloc(sizeof *dev
+ device
->phys_port_cnt
* sizeof *port
,
830 dev
->start_port
= rdma_start_port(device
);
831 dev
->end_port
= rdma_end_port(device
);
833 for (i
= 0; i
<= dev
->end_port
- dev
->start_port
; i
++) {
834 if (!rdma_cap_ib_mcast(device
, dev
->start_port
+ i
))
836 port
= &dev
->port
[i
];
838 port
->port_num
= dev
->start_port
+ i
;
839 spin_lock_init(&port
->lock
);
840 port
->table
= RB_ROOT
;
841 init_completion(&port
->comp
);
842 atomic_set(&port
->refcount
, 1);
851 dev
->device
= device
;
852 ib_set_client_data(device
, &mcast_client
, dev
);
854 INIT_IB_EVENT_HANDLER(&dev
->event_handler
, device
, mcast_event_handler
);
855 ib_register_event_handler(&dev
->event_handler
);
858 static void mcast_remove_one(struct ib_device
*device
, void *client_data
)
860 struct mcast_device
*dev
= client_data
;
861 struct mcast_port
*port
;
867 ib_unregister_event_handler(&dev
->event_handler
);
868 flush_workqueue(mcast_wq
);
870 for (i
= 0; i
<= dev
->end_port
- dev
->start_port
; i
++) {
871 if (rdma_cap_ib_mcast(device
, dev
->start_port
+ i
)) {
872 port
= &dev
->port
[i
];
874 wait_for_completion(&port
->comp
);
885 mcast_wq
= create_singlethread_workqueue("ib_mcast");
889 ib_sa_register_client(&sa_client
);
891 ret
= ib_register_client(&mcast_client
);
897 ib_sa_unregister_client(&sa_client
);
898 destroy_workqueue(mcast_wq
);
902 void mcast_cleanup(void)
904 ib_unregister_client(&mcast_client
);
905 ib_sa_unregister_client(&sa_client
);
906 destroy_workqueue(mcast_wq
);