infiniband/core/ib_multicast.c

124 	struct mcast_group	*group;
140 	struct mcast_group *group;
144 		group = rb_entry(node, struct mcast_group, node);
145 		ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid);
147 			return group;
158 					struct mcast_group *group,
170 		ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw,
171 			     sizeof group->rec.mgid);
181 	rb_link_node(&group->node, parent, link);
182 	rb_insert_color(&group->node, &port->table);
192 static void release_group(struct mcast_group *group)
194 	struct mcast_port *port = group->port;
198 	if (atomic_dec_and_test(&group->refcount)) {
199 		rb_erase(&group->node, &port->table);
201 		kfree(group);
215 	struct mcast_group *group = member->group;
218 	spin_lock_irqsave(&group->lock, flags);
219 	list_add_tail(&member->list, &group->pending_list);
220 	if (group->state == MCAST_IDLE) {
221 		group->state = MCAST_BUSY;
222 		atomic_inc(&group->refcount);
223 		queue_work(mcast_wq, &group->work);
225 	spin_unlock_irqrestore(&group->lock, flags);
229  * A multicast group has four types of members: full member, non member,
235 static void adjust_membership(struct mcast_group *group, u8 join_state, int inc)
241 			group->members[i] += inc;
245  * If a multicast group has zero members left for a particular join state, but
246  * the group is still a member with the SA, we need to leave that join state.
250 static u8 get_leave_state(struct mcast_group *group)
256 		if (!group->members[i])
259 	return leave_state & group->rec.join_state;
337 static int send_join(struct mcast_group *group, struct mcast_member *member)
339 	struct mcast_port *port = group->port;
342 	group->last_join = member;
347 				       3000, GFP_KERNEL, join_handler, group,
348 				       &group->query);
352 static int send_leave(struct mcast_group *group, u8 leave_state)
354 	struct mcast_port *port = group->port;
358 	rec = group->rec;
360 	group->leave_state = leave_state;
368 				       group, &group->query);
372 static void join_group(struct mcast_group *group, struct mcast_member *member,
376 	adjust_membership(group, join_state, 1);
377 	group->rec.join_state |= join_state;
378 	member->multicast.rec = group->rec;
380 	list_move(&member->list, &group->active_list);
383 static int fail_join(struct mcast_group *group, struct mcast_member *member,
386 	spin_lock_irq(&group->lock);
388 	spin_unlock_irq(&group->lock);
392 static void process_group_error(struct mcast_group *group)
398 	if (group->state == MCAST_PKEY_EVENT)
399 		ret = ib_find_pkey(group->port->dev->device,
400 				   group->port->port_num,
401 				   be16_to_cpu(group->rec.pkey), &pkey_index);
403 	spin_lock_irq(&group->lock);
404 	if (group->state == MCAST_PKEY_EVENT && !ret &&
405 	    group->pkey_index == pkey_index)
408 	while (!list_empty(&group->active_list)) {
409 		member = list_entry(group->active_list.next,
413 		adjust_membership(group, member->multicast.rec.join_state, -1);
415 		spin_unlock_irq(&group->lock);
422 		spin_lock_irq(&group->lock);
425 	group->rec.join_state = 0;
427 	group->state = MCAST_BUSY;
428 	spin_unlock_irq(&group->lock);
433 	struct mcast_group *group;
439 	group = container_of(work, typeof(*group), work);
441 	spin_lock_irq(&group->lock);
442 	while (!list_empty(&group->pending_list) ||
443 	       (group->state != MCAST_BUSY)) {
445 		if (group->state != MCAST_BUSY) {
446 			spin_unlock_irq(&group->lock);
447 			process_group_error(group);
451 		member = list_entry(group->pending_list.next,
457 		if (join_state == (group->rec.join_state & join_state)) {
458 			status = cmp_rec(&group->rec, &multicast->rec,
461 				join_group(group, member, join_state);
464 			spin_unlock_irq(&group->lock);
467 			spin_unlock_irq(&group->lock);
468 			status = send_join(group, member);
473 			ret = fail_join(group, member, status);
479 		spin_lock_irq(&group->lock);
482 	join_state = get_leave_state(group);
484 		group->rec.join_state &= ~join_state;
485 		spin_unlock_irq(&group->lock);
486 		if (send_leave(group, join_state))
489 		group->state = MCAST_IDLE;
490 		spin_unlock_irq(&group->lock);
491 		release_group(group);
498 static void process_join_error(struct mcast_group *group, int status)
503 	spin_lock_irq(&group->lock);
504 	member = list_entry(group->pending_list.next,
506 	if (group->last_join == member) {
509 		spin_unlock_irq(&group->lock);
515 		spin_unlock_irq(&group->lock);
521 	struct mcast_group *group = context;
525 		process_join_error(group, status);
528 		if (ib_find_pkey(group->port->dev->device, group->port->port_num,
532 		spin_lock_irq(&group->port->lock);
533 		if (group->state == MCAST_BUSY &&
534 		    group->pkey_index == MCAST_INVALID_PKEY_INDEX)
535 			group->pkey_index = pkey_index;
536 		mgids_changed = memcmp(&rec->mgid, &group->rec.mgid,
537 				       sizeof(group->rec.mgid));
538 		group->rec = *rec;
540 			rb_erase(&group->node, &group->port->table);
541 			is_mgid0 = !memcmp(&mgid0, &group->rec.mgid,
543 			mcast_insert(group->port, group, is_mgid0);
545 		spin_unlock_irq(&group->port->lock);
547 	mcast_work_handler(&group->work);
553 	struct mcast_group *group = context;
555 	if (status && group->retries > 0 &&
556 	    !send_leave(group, group->leave_state))
557 		group->retries--;
559 		mcast_work_handler(&group->work);
565 	struct mcast_group *group, *cur_group;
572 		group = mcast_find(port, mgid);
573 		if (group)
578 	group = kzalloc(sizeof *group, gfp_mask);
579 	if (!group)
582 	group->retries = 3;
583 	group->port = port;
584 	group->rec.mgid = *mgid;
585 	group->pkey_index = MCAST_INVALID_PKEY_INDEX;
586 	INIT_LIST_HEAD(&group->pending_list);
587 	INIT_LIST_HEAD(&group->active_list);
588 	INIT_WORK(&group->work, mcast_work_handler);
589 	spin_lock_init(&group->lock);
592 	cur_group = mcast_insert(port, group, is_mgid0);
594 		kfree(group);
595 		group = cur_group;
599 	atomic_inc(&group->refcount);
601 	return group;
605  * We serialize all join requests to a single group to make our lives much
606  * easier.  Otherwise, two users could try to join the same group
643 	member->group = acquire_group(&dev->port[port_num - dev->start_port],
645 	if (!member->group) {
670 	struct mcast_group *group;
673 	group = member->group;
675 	spin_lock_irq(&group->lock);
677 		adjust_membership(group, multicast->rec.join_state, -1);
681 	if (group->state == MCAST_IDLE) {
682 		group->state = MCAST_BUSY;
683 		spin_unlock_irq(&group->lock);
684 		/* Continue to hold reference on group until callback */
685 		queue_work(mcast_wq, &group->work);
687 		spin_unlock_irq(&group->lock);
688 		release_group(group);
703 	struct mcast_group *group;
713 	group = mcast_find(port, mgid);
714 	if (group)
715 		*rec = group->rec;
769 	struct mcast_group *group;
775 		group = rb_entry(node, struct mcast_group, node);
776 		spin_lock(&group->lock);
777 		if (group->state == MCAST_IDLE) {
778 			atomic_inc(&group->refcount);
779 			queue_work(mcast_wq, &group->work);
781 		if (group->state != MCAST_GROUP_ERROR)
782 			group->state = state;
783 		spin_unlock(&group->lock);