1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0 3 * 4 * Copyright (c) 2006 Intel Corporation. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 * 34 * $FreeBSD$ 35 */ 36 37 #define LINUXKPI_PARAM_PREFIX ibcore_ 38 39 #include <linux/completion.h> 40 #include <linux/dma-mapping.h> 41 #include <linux/err.h> 42 #include <linux/interrupt.h> 43 #include <linux/slab.h> 44 #include <linux/bitops.h> 45 #include <linux/random.h> 46 #include <linux/rbtree.h> 47 48 #include <rdma/ib_cache.h> 49 #include "sa.h" 50 51 static void mcast_add_one(struct ib_device *device); 52 static void mcast_remove_one(struct ib_device *device, void *client_data); 53 54 static struct ib_client mcast_client = { 55 .name = "ib_multicast", 56 .add = mcast_add_one, 57 .remove = mcast_remove_one 58 }; 59 60 static struct ib_sa_client sa_client; 61 static struct workqueue_struct *mcast_wq; 62 static union ib_gid mgid0; 63 64 struct mcast_device; 65 66 struct mcast_port { 67 struct mcast_device *dev; 68 spinlock_t lock; 69 struct rb_root table; 70 atomic_t refcount; 71 struct completion comp; 72 u8 port_num; 73 }; 74 75 struct mcast_device { 76 struct ib_device *device; 77 struct ib_event_handler event_handler; 78 int start_port; 79 int end_port; 80 struct mcast_port port[0]; 81 }; 82 83 enum mcast_state { 84 MCAST_JOINING, 85 MCAST_MEMBER, 86 MCAST_ERROR, 87 }; 88 89 enum mcast_group_state { 90 MCAST_IDLE, 91 MCAST_BUSY, 92 MCAST_GROUP_ERROR, 93 MCAST_PKEY_EVENT 94 }; 95 96 enum { 97 MCAST_INVALID_PKEY_INDEX = 0xFFFF 98 }; 99 100 struct mcast_member; 101 102 struct mcast_group { 103 struct ib_sa_mcmember_rec rec; 104 struct rb_node node; 105 struct mcast_port *port; 106 spinlock_t lock; 107 struct work_struct work; 108 struct list_head pending_list; 109 struct list_head active_list; 110 struct mcast_member *last_join; 111 int members[NUM_JOIN_MEMBERSHIP_TYPES]; 112 atomic_t refcount; 113 enum mcast_group_state state; 114 struct ib_sa_query *query; 115 u16 pkey_index; 116 u8 leave_state; 117 int retries; 118 }; 119 120 struct mcast_member { 121 struct ib_sa_multicast multicast; 122 struct ib_sa_client *client; 123 struct mcast_group *group; 124 struct list_head list; 125 enum mcast_state state; 126 atomic_t refcount; 127 struct completion comp; 128 }; 129 130 static void join_handler(int status, struct ib_sa_mcmember_rec *rec, 131 void *context); 132 static void leave_handler(int status, struct ib_sa_mcmember_rec *rec, 133 void *context); 134 135 static struct mcast_group *mcast_find(struct mcast_port *port, 136 union ib_gid *mgid) 137 { 138 struct rb_node *node = port->table.rb_node; 139 struct mcast_group *group; 140 int ret; 141 142 while (node) { 143 group = rb_entry(node, struct mcast_group, node); 144 ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid); 145 if (!ret) 146 return group; 147 148 if (ret < 0) 149 node = node->rb_left; 150 else 151 node = node->rb_right; 152 } 153 return NULL; 154 } 155 156 static struct mcast_group *mcast_insert(struct mcast_port *port, 157 struct mcast_group *group, 158 int allow_duplicates) 159 { 160 struct rb_node **link = &port->table.rb_node; 161 struct rb_node *parent = NULL; 162 struct mcast_group *cur_group; 163 int ret; 164 165 while (*link) { 166 parent = *link; 167 cur_group = rb_entry(parent, struct mcast_group, node); 168 169 ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw, 170 sizeof group->rec.mgid); 171 if (ret < 0) 172 link = &(*link)->rb_left; 173 else if (ret > 0) 174 link = &(*link)->rb_right; 175 else if (allow_duplicates) 176 link = &(*link)->rb_left; 177 else 178 return cur_group; 179 } 180 rb_link_node(&group->node, parent, link); 181 rb_insert_color(&group->node, &port->table); 182 return NULL; 183 } 184 185 static void deref_port(struct mcast_port *port) 186 { 187 if (atomic_dec_and_test(&port->refcount)) 188 complete(&port->comp); 189 } 190 191 static void release_group(struct mcast_group *group) 192 { 193 struct mcast_port *port = group->port; 194 unsigned long flags; 195 196 spin_lock_irqsave(&port->lock, flags); 197 if (atomic_dec_and_test(&group->refcount)) { 198 rb_erase(&group->node, &port->table); 199 spin_unlock_irqrestore(&port->lock, flags); 200 kfree(group); 201 deref_port(port); 202 } else 203 spin_unlock_irqrestore(&port->lock, flags); 204 } 205 206 static void deref_member(struct mcast_member *member) 207 { 208 if (atomic_dec_and_test(&member->refcount)) 209 complete(&member->comp); 210 } 211 212 static void queue_join(struct mcast_member *member) 213 { 214 struct mcast_group *group = member->group; 215 unsigned long flags; 216 217 spin_lock_irqsave(&group->lock, flags); 218 list_add_tail(&member->list, &group->pending_list); 219 if (group->state == MCAST_IDLE) { 220 group->state = MCAST_BUSY; 221 atomic_inc(&group->refcount); 222 queue_work(mcast_wq, &group->work); 223 } 224 spin_unlock_irqrestore(&group->lock, flags); 225 } 226 227 /* 228 * A multicast group has four types of members: full member, non member, 229 * sendonly non member and sendonly full member. 230 * We need to keep track of the number of members of each 231 * type based on their join state. Adjust the number of members the belong to 232 * the specified join states. 233 */ 234 static void adjust_membership(struct mcast_group *group, u8 join_state, int inc) 235 { 236 int i; 237 238 for (i = 0; i < NUM_JOIN_MEMBERSHIP_TYPES; i++, join_state >>= 1) 239 if (join_state & 0x1) 240 group->members[i] += inc; 241 } 242 243 /* 244 * If a multicast group has zero members left for a particular join state, but 245 * the group is still a member with the SA, we need to leave that join state. 246 * Determine which join states we still belong to, but that do not have any 247 * active members. 248 */ 249 static u8 get_leave_state(struct mcast_group *group) 250 { 251 u8 leave_state = 0; 252 int i; 253 254 for (i = 0; i < NUM_JOIN_MEMBERSHIP_TYPES; i++) 255 if (!group->members[i]) 256 leave_state |= (0x1 << i); 257 258 return leave_state & group->rec.join_state; 259 } 260 261 static int check_selector(ib_sa_comp_mask comp_mask, 262 ib_sa_comp_mask selector_mask, 263 ib_sa_comp_mask value_mask, 264 u8 selector, u8 src_value, u8 dst_value) 265 { 266 int err; 267 268 if (!(comp_mask & selector_mask) || !(comp_mask & value_mask)) 269 return 0; 270 271 switch (selector) { 272 case IB_SA_GT: 273 err = (src_value <= dst_value); 274 break; 275 case IB_SA_LT: 276 err = (src_value >= dst_value); 277 break; 278 case IB_SA_EQ: 279 err = (src_value != dst_value); 280 break; 281 default: 282 err = 0; 283 break; 284 } 285 286 return err; 287 } 288 289 static int cmp_rec(struct ib_sa_mcmember_rec *src, 290 struct ib_sa_mcmember_rec *dst, ib_sa_comp_mask comp_mask) 291 { 292 /* MGID must already match */ 293 294 if (comp_mask & IB_SA_MCMEMBER_REC_PORT_GID && 295 memcmp(&src->port_gid, &dst->port_gid, sizeof src->port_gid)) 296 return -EINVAL; 297 if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey) 298 return -EINVAL; 299 if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid) 300 return -EINVAL; 301 if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_MTU_SELECTOR, 302 IB_SA_MCMEMBER_REC_MTU, dst->mtu_selector, 303 src->mtu, dst->mtu)) 304 return -EINVAL; 305 if (comp_mask & IB_SA_MCMEMBER_REC_TRAFFIC_CLASS && 306 src->traffic_class != dst->traffic_class) 307 return -EINVAL; 308 if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey) 309 return -EINVAL; 310 if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_RATE_SELECTOR, 311 IB_SA_MCMEMBER_REC_RATE, dst->rate_selector, 312 src->rate, dst->rate)) 313 return -EINVAL; 314 if (check_selector(comp_mask, 315 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR, 316 IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME, 317 dst->packet_life_time_selector, 318 src->packet_life_time, dst->packet_life_time)) 319 return -EINVAL; 320 if (comp_mask & IB_SA_MCMEMBER_REC_SL && src->sl != dst->sl) 321 return -EINVAL; 322 if (comp_mask & IB_SA_MCMEMBER_REC_FLOW_LABEL && 323 src->flow_label != dst->flow_label) 324 return -EINVAL; 325 if (comp_mask & IB_SA_MCMEMBER_REC_HOP_LIMIT && 326 src->hop_limit != dst->hop_limit) 327 return -EINVAL; 328 if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE && src->scope != dst->scope) 329 return -EINVAL; 330 331 /* join_state checked separately, proxy_join ignored */ 332 333 return 0; 334 } 335 336 static int send_join(struct mcast_group *group, struct mcast_member *member) 337 { 338 struct mcast_port *port = group->port; 339 int ret; 340 341 group->last_join = member; 342 ret = ib_sa_mcmember_rec_query(&sa_client, port->dev->device, 343 port->port_num, IB_MGMT_METHOD_SET, 344 &member->multicast.rec, 345 member->multicast.comp_mask, 346 3000, GFP_KERNEL, join_handler, group, 347 &group->query); 348 return (ret > 0) ? 0 : ret; 349 } 350 351 static int send_leave(struct mcast_group *group, u8 leave_state) 352 { 353 struct mcast_port *port = group->port; 354 struct ib_sa_mcmember_rec rec; 355 int ret; 356 357 rec = group->rec; 358 rec.join_state = leave_state; 359 group->leave_state = leave_state; 360 361 ret = ib_sa_mcmember_rec_query(&sa_client, port->dev->device, 362 port->port_num, IB_SA_METHOD_DELETE, &rec, 363 IB_SA_MCMEMBER_REC_MGID | 364 IB_SA_MCMEMBER_REC_PORT_GID | 365 IB_SA_MCMEMBER_REC_JOIN_STATE, 366 3000, GFP_KERNEL, leave_handler, 367 group, &group->query); 368 return (ret > 0) ? 0 : ret; 369 } 370 371 static void join_group(struct mcast_group *group, struct mcast_member *member, 372 u8 join_state) 373 { 374 member->state = MCAST_MEMBER; 375 adjust_membership(group, join_state, 1); 376 group->rec.join_state |= join_state; 377 member->multicast.rec = group->rec; 378 member->multicast.rec.join_state = join_state; 379 list_move(&member->list, &group->active_list); 380 } 381 382 static int fail_join(struct mcast_group *group, struct mcast_member *member, 383 int status) 384 { 385 spin_lock_irq(&group->lock); 386 list_del_init(&member->list); 387 spin_unlock_irq(&group->lock); 388 return member->multicast.callback(status, &member->multicast); 389 } 390 391 static void process_group_error(struct mcast_group *group) 392 { 393 struct mcast_member *member; 394 int ret = 0; 395 u16 pkey_index; 396 397 if (group->state == MCAST_PKEY_EVENT) 398 ret = ib_find_pkey(group->port->dev->device, 399 group->port->port_num, 400 be16_to_cpu(group->rec.pkey), &pkey_index); 401 402 spin_lock_irq(&group->lock); 403 if (group->state == MCAST_PKEY_EVENT && !ret && 404 group->pkey_index == pkey_index) 405 goto out; 406 407 while (!list_empty(&group->active_list)) { 408 member = list_entry(group->active_list.next, 409 struct mcast_member, list); 410 atomic_inc(&member->refcount); 411 list_del_init(&member->list); 412 adjust_membership(group, member->multicast.rec.join_state, -1); 413 member->state = MCAST_ERROR; 414 spin_unlock_irq(&group->lock); 415 416 ret = member->multicast.callback(-ENETRESET, 417 &member->multicast); 418 deref_member(member); 419 if (ret) 420 ib_sa_free_multicast(&member->multicast); 421 spin_lock_irq(&group->lock); 422 } 423 424 group->rec.join_state = 0; 425 out: 426 group->state = MCAST_BUSY; 427 spin_unlock_irq(&group->lock); 428 } 429 430 static void mcast_work_handler(struct work_struct *work) 431 { 432 struct mcast_group *group; 433 struct mcast_member *member; 434 struct ib_sa_multicast *multicast; 435 int status, ret; 436 u8 join_state; 437 438 group = container_of(work, typeof(*group), work); 439 retest: 440 spin_lock_irq(&group->lock); 441 while (!list_empty(&group->pending_list) || 442 (group->state != MCAST_BUSY)) { 443 444 if (group->state != MCAST_BUSY) { 445 spin_unlock_irq(&group->lock); 446 process_group_error(group); 447 goto retest; 448 } 449 450 member = list_entry(group->pending_list.next, 451 struct mcast_member, list); 452 multicast = &member->multicast; 453 join_state = multicast->rec.join_state; 454 atomic_inc(&member->refcount); 455 456 if (join_state == (group->rec.join_state & join_state)) { 457 status = cmp_rec(&group->rec, &multicast->rec, 458 multicast->comp_mask); 459 if (!status) 460 join_group(group, member, join_state); 461 else 462 list_del_init(&member->list); 463 spin_unlock_irq(&group->lock); 464 ret = multicast->callback(status, multicast); 465 } else { 466 spin_unlock_irq(&group->lock); 467 status = send_join(group, member); 468 if (!status) { 469 deref_member(member); 470 return; 471 } 472 ret = fail_join(group, member, status); 473 } 474 475 deref_member(member); 476 if (ret) 477 ib_sa_free_multicast(&member->multicast); 478 spin_lock_irq(&group->lock); 479 } 480 481 join_state = get_leave_state(group); 482 if (join_state) { 483 group->rec.join_state &= ~join_state; 484 spin_unlock_irq(&group->lock); 485 if (send_leave(group, join_state)) 486 goto retest; 487 } else { 488 group->state = MCAST_IDLE; 489 spin_unlock_irq(&group->lock); 490 release_group(group); 491 } 492 } 493 494 /* 495 * Fail a join request if it is still active - at the head of the pending queue. 496 */ 497 static void process_join_error(struct mcast_group *group, int status) 498 { 499 struct mcast_member *member; 500 int ret; 501 502 spin_lock_irq(&group->lock); 503 member = list_entry(group->pending_list.next, 504 struct mcast_member, list); 505 if (group->last_join == member) { 506 atomic_inc(&member->refcount); 507 list_del_init(&member->list); 508 spin_unlock_irq(&group->lock); 509 ret = member->multicast.callback(status, &member->multicast); 510 deref_member(member); 511 if (ret) 512 ib_sa_free_multicast(&member->multicast); 513 } else 514 spin_unlock_irq(&group->lock); 515 } 516 517 static void join_handler(int status, struct ib_sa_mcmember_rec *rec, 518 void *context) 519 { 520 struct mcast_group *group = context; 521 u16 pkey_index = MCAST_INVALID_PKEY_INDEX; 522 523 if (status) 524 process_join_error(group, status); 525 else { 526 int mgids_changed, is_mgid0; 527 ib_find_pkey(group->port->dev->device, group->port->port_num, 528 be16_to_cpu(rec->pkey), &pkey_index); 529 530 spin_lock_irq(&group->port->lock); 531 if (group->state == MCAST_BUSY && 532 group->pkey_index == MCAST_INVALID_PKEY_INDEX) 533 group->pkey_index = pkey_index; 534 mgids_changed = memcmp(&rec->mgid, &group->rec.mgid, 535 sizeof(group->rec.mgid)); 536 group->rec = *rec; 537 if (mgids_changed) { 538 rb_erase(&group->node, &group->port->table); 539 is_mgid0 = !memcmp(&mgid0, &group->rec.mgid, 540 sizeof(mgid0)); 541 mcast_insert(group->port, group, is_mgid0); 542 } 543 spin_unlock_irq(&group->port->lock); 544 } 545 mcast_work_handler(&group->work); 546 } 547 548 static void leave_handler(int status, struct ib_sa_mcmember_rec *rec, 549 void *context) 550 { 551 struct mcast_group *group = context; 552 553 if (status && group->retries > 0 && 554 !send_leave(group, group->leave_state)) 555 group->retries--; 556 else 557 mcast_work_handler(&group->work); 558 } 559 560 static struct mcast_group *acquire_group(struct mcast_port *port, 561 union ib_gid *mgid, gfp_t gfp_mask) 562 { 563 struct mcast_group *group, *cur_group; 564 unsigned long flags; 565 int is_mgid0; 566 567 is_mgid0 = !memcmp(&mgid0, mgid, sizeof mgid0); 568 if (!is_mgid0) { 569 spin_lock_irqsave(&port->lock, flags); 570 group = mcast_find(port, mgid); 571 if (group) 572 goto found; 573 spin_unlock_irqrestore(&port->lock, flags); 574 } 575 576 group = kzalloc(sizeof *group, gfp_mask); 577 if (!group) 578 return NULL; 579 580 group->retries = 3; 581 group->port = port; 582 group->rec.mgid = *mgid; 583 group->pkey_index = MCAST_INVALID_PKEY_INDEX; 584 INIT_LIST_HEAD(&group->pending_list); 585 INIT_LIST_HEAD(&group->active_list); 586 INIT_WORK(&group->work, mcast_work_handler); 587 spin_lock_init(&group->lock); 588 589 spin_lock_irqsave(&port->lock, flags); 590 cur_group = mcast_insert(port, group, is_mgid0); 591 if (cur_group) { 592 kfree(group); 593 group = cur_group; 594 } else 595 atomic_inc(&port->refcount); 596 found: 597 atomic_inc(&group->refcount); 598 spin_unlock_irqrestore(&port->lock, flags); 599 return group; 600 } 601 602 /* 603 * We serialize all join requests to a single group to make our lives much 604 * easier. Otherwise, two users could try to join the same group 605 * simultaneously, with different configurations, one could leave while the 606 * join is in progress, etc., which makes locking around error recovery 607 * difficult. 608 */ 609 struct ib_sa_multicast * 610 ib_sa_join_multicast(struct ib_sa_client *client, 611 struct ib_device *device, u8 port_num, 612 struct ib_sa_mcmember_rec *rec, 613 ib_sa_comp_mask comp_mask, gfp_t gfp_mask, 614 int (*callback)(int status, 615 struct ib_sa_multicast *multicast), 616 void *context) 617 { 618 struct mcast_device *dev; 619 struct mcast_member *member; 620 struct ib_sa_multicast *multicast; 621 int ret; 622 623 dev = ib_get_client_data(device, &mcast_client); 624 if (!dev) 625 return ERR_PTR(-ENODEV); 626 627 member = kmalloc(sizeof *member, gfp_mask); 628 if (!member) 629 return ERR_PTR(-ENOMEM); 630 631 ib_sa_client_get(client); 632 member->client = client; 633 member->multicast.rec = *rec; 634 member->multicast.comp_mask = comp_mask; 635 member->multicast.callback = callback; 636 member->multicast.context = context; 637 init_completion(&member->comp); 638 atomic_set(&member->refcount, 1); 639 member->state = MCAST_JOINING; 640 641 member->group = acquire_group(&dev->port[port_num - dev->start_port], 642 &rec->mgid, gfp_mask); 643 if (!member->group) { 644 ret = -ENOMEM; 645 goto err; 646 } 647 648 /* 649 * The user will get the multicast structure in their callback. They 650 * could then free the multicast structure before we can return from 651 * this routine. So we save the pointer to return before queuing 652 * any callback. 653 */ 654 multicast = &member->multicast; 655 queue_join(member); 656 return multicast; 657 658 err: 659 ib_sa_client_put(client); 660 kfree(member); 661 return ERR_PTR(ret); 662 } 663 EXPORT_SYMBOL(ib_sa_join_multicast); 664 665 void ib_sa_free_multicast(struct ib_sa_multicast *multicast) 666 { 667 struct mcast_member *member; 668 struct mcast_group *group; 669 670 member = container_of(multicast, struct mcast_member, multicast); 671 group = member->group; 672 673 spin_lock_irq(&group->lock); 674 if (member->state == MCAST_MEMBER) 675 adjust_membership(group, multicast->rec.join_state, -1); 676 677 list_del_init(&member->list); 678 679 if (group->state == MCAST_IDLE) { 680 group->state = MCAST_BUSY; 681 spin_unlock_irq(&group->lock); 682 /* Continue to hold reference on group until callback */ 683 queue_work(mcast_wq, &group->work); 684 } else { 685 spin_unlock_irq(&group->lock); 686 release_group(group); 687 } 688 689 deref_member(member); 690 wait_for_completion(&member->comp); 691 ib_sa_client_put(member->client); 692 kfree(member); 693 } 694 EXPORT_SYMBOL(ib_sa_free_multicast); 695 696 int ib_sa_get_mcmember_rec(struct ib_device *device, u8 port_num, 697 union ib_gid *mgid, struct ib_sa_mcmember_rec *rec) 698 { 699 struct mcast_device *dev; 700 struct mcast_port *port; 701 struct mcast_group *group; 702 unsigned long flags; 703 int ret = 0; 704 705 dev = ib_get_client_data(device, &mcast_client); 706 if (!dev) 707 return -ENODEV; 708 709 port = &dev->port[port_num - dev->start_port]; 710 spin_lock_irqsave(&port->lock, flags); 711 group = mcast_find(port, mgid); 712 if (group) 713 *rec = group->rec; 714 else 715 ret = -EADDRNOTAVAIL; 716 spin_unlock_irqrestore(&port->lock, flags); 717 718 return ret; 719 } 720 EXPORT_SYMBOL(ib_sa_get_mcmember_rec); 721 722 int ib_init_ah_from_mcmember(struct ib_device *device, u8 port_num, 723 struct ib_sa_mcmember_rec *rec, 724 struct net_device *ndev, 725 enum ib_gid_type gid_type, 726 struct ib_ah_attr *ah_attr) 727 { 728 int ret; 729 u16 gid_index; 730 u8 p; 731 732 if (rdma_protocol_roce(device, port_num)) { 733 ret = ib_find_cached_gid_by_port(device, &rec->port_gid, 734 gid_type, port_num, 735 ndev, 736 &gid_index); 737 } else if (rdma_protocol_ib(device, port_num)) { 738 ret = ib_find_cached_gid(device, &rec->port_gid, 739 IB_GID_TYPE_IB, NULL, &p, 740 &gid_index); 741 } else { 742 ret = -EINVAL; 743 } 744 745 if (ret) 746 return ret; 747 748 memset(ah_attr, 0, sizeof *ah_attr); 749 ah_attr->dlid = be16_to_cpu(rec->mlid); 750 ah_attr->sl = rec->sl; 751 ah_attr->port_num = port_num; 752 ah_attr->static_rate = rec->rate; 753 754 ah_attr->ah_flags = IB_AH_GRH; 755 ah_attr->grh.dgid = rec->mgid; 756 757 ah_attr->grh.sgid_index = (u8) gid_index; 758 ah_attr->grh.flow_label = be32_to_cpu(rec->flow_label); 759 ah_attr->grh.hop_limit = rec->hop_limit; 760 ah_attr->grh.traffic_class = rec->traffic_class; 761 762 return 0; 763 } 764 EXPORT_SYMBOL(ib_init_ah_from_mcmember); 765 766 static void mcast_groups_event(struct mcast_port *port, 767 enum mcast_group_state state) 768 { 769 struct mcast_group *group; 770 struct rb_node *node; 771 unsigned long flags; 772 773 spin_lock_irqsave(&port->lock, flags); 774 for (node = rb_first(&port->table); node; node = rb_next(node)) { 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); 780 } 781 if (group->state != MCAST_GROUP_ERROR) 782 group->state = state; 783 spin_unlock(&group->lock); 784 } 785 spin_unlock_irqrestore(&port->lock, flags); 786 } 787 788 static void mcast_event_handler(struct ib_event_handler *handler, 789 struct ib_event *event) 790 { 791 struct mcast_device *dev; 792 int index; 793 794 dev = container_of(handler, struct mcast_device, event_handler); 795 if (!rdma_cap_ib_mcast(dev->device, event->element.port_num)) 796 return; 797 798 index = event->element.port_num - dev->start_port; 799 800 switch (event->event) { 801 case IB_EVENT_PORT_ERR: 802 case IB_EVENT_LID_CHANGE: 803 case IB_EVENT_SM_CHANGE: 804 case IB_EVENT_CLIENT_REREGISTER: 805 mcast_groups_event(&dev->port[index], MCAST_GROUP_ERROR); 806 break; 807 case IB_EVENT_PKEY_CHANGE: 808 mcast_groups_event(&dev->port[index], MCAST_PKEY_EVENT); 809 break; 810 default: 811 break; 812 } 813 } 814 815 static void mcast_add_one(struct ib_device *device) 816 { 817 struct mcast_device *dev; 818 struct mcast_port *port; 819 int i; 820 int count = 0; 821 822 dev = kmalloc(sizeof *dev + device->phys_port_cnt * sizeof *port, 823 GFP_KERNEL); 824 if (!dev) 825 return; 826 827 dev->start_port = rdma_start_port(device); 828 dev->end_port = rdma_end_port(device); 829 830 for (i = 0; i <= dev->end_port - dev->start_port; i++) { 831 if (!rdma_cap_ib_mcast(device, dev->start_port + i)) 832 continue; 833 port = &dev->port[i]; 834 port->dev = dev; 835 port->port_num = dev->start_port + i; 836 spin_lock_init(&port->lock); 837 port->table = RB_ROOT; 838 init_completion(&port->comp); 839 atomic_set(&port->refcount, 1); 840 ++count; 841 } 842 843 if (!count) { 844 kfree(dev); 845 return; 846 } 847 848 dev->device = device; 849 ib_set_client_data(device, &mcast_client, dev); 850 851 INIT_IB_EVENT_HANDLER(&dev->event_handler, device, mcast_event_handler); 852 ib_register_event_handler(&dev->event_handler); 853 } 854 855 static void mcast_remove_one(struct ib_device *device, void *client_data) 856 { 857 struct mcast_device *dev = client_data; 858 struct mcast_port *port; 859 int i; 860 861 if (!dev) 862 return; 863 864 ib_unregister_event_handler(&dev->event_handler); 865 flush_workqueue(mcast_wq); 866 867 for (i = 0; i <= dev->end_port - dev->start_port; i++) { 868 if (rdma_cap_ib_mcast(device, dev->start_port + i)) { 869 port = &dev->port[i]; 870 deref_port(port); 871 wait_for_completion(&port->comp); 872 } 873 } 874 875 kfree(dev); 876 } 877 878 int mcast_init(void) 879 { 880 int ret; 881 882 mcast_wq = alloc_ordered_workqueue("ib_mcast", WQ_MEM_RECLAIM); 883 if (!mcast_wq) 884 return -ENOMEM; 885 886 ib_sa_register_client(&sa_client); 887 888 ret = ib_register_client(&mcast_client); 889 if (ret) 890 goto err; 891 return 0; 892 893 err: 894 ib_sa_unregister_client(&sa_client); 895 destroy_workqueue(mcast_wq); 896 return ret; 897 } 898 899 void mcast_cleanup(void) 900 { 901 ib_unregister_client(&mcast_client); 902 ib_sa_unregister_client(&sa_client); 903 destroy_workqueue(mcast_wq); 904 } 905