drivers/infiniband/core/multicast.c

   1 /*
   2  * Copyright (c) 2006 Intel Corporation.  All rights reserved.
   3  *
   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:
   9  *
  10  *     Redistribution and use in source and binary forms, with or
  11  *     without modification, are permitted provided that the following
  12  *     conditions are met:
  13  *
  14  *      - Redistributions of source code must retain the above
  15  *        copyright notice, this list of conditions and the following
  16  *        disclaimer.
  17  *
  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.
  22  *
  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
  30  * SOFTWARE.
  31  */
  32
  33 #include <linux/completion.h>
  34 #include <linux/dma-mapping.h>
  35 #include <linux/err.h>
  36 #include <linux/interrupt.h>
  37 #include <linux/bitops.h>
  38 #include <linux/random.h>
  39
  40 #include <rdma/ib_cache.h>
  41 #include "sa.h"
  42
  43 static void mcast_add_one(struct ib_device *device);
  44 static void mcast_remove_one(struct ib_device *device);
  45
  46 static struct ib_client mcast_client = {
  47         .name   = "ib_multicast",
  48         .add    = mcast_add_one,
  49         .remove = mcast_remove_one
  50 };
  51
  52 static struct ib_sa_client      sa_client;
  53 static struct workqueue_struct  *mcast_wq;
  54 static union ib_gid mgid0;
  55
  56 struct mcast_device;
  57
  58 struct mcast_port {
  59         struct mcast_device     *dev;
  60         spinlock_t              lock;
  61         struct rb_root          table;
  62         atomic_t                refcount;
  63         struct completion       comp;
  64         u8                      port_num;
  65 };
  66
  67 struct mcast_device {
  68         struct ib_device        *device;
  69         struct ib_event_handler event_handler;
  70         int                     start_port;
  71         int                     end_port;
  72         struct mcast_port       port[0];
  73 };
  74
  75 enum mcast_state {
  76         MCAST_JOINING,
  77         MCAST_MEMBER,
  78         MCAST_ERROR,
  79 };
  80
  81 enum mcast_group_state {
  82         MCAST_IDLE,
  83         MCAST_BUSY,
  84         MCAST_GROUP_ERROR,
  85         MCAST_PKEY_EVENT
  86 };
  87
  88 enum {
  89         MCAST_INVALID_PKEY_INDEX = 0xFFFF
  90 };
  91
  92 struct mcast_member;
  93
  94 struct mcast_group {
  95         struct ib_sa_mcmember_rec rec;
  96         struct rb_node          node;
  97         struct mcast_port       *port;
  98         spinlock_t              lock;
  99         struct work_struct      work;
 100         struct list_head        pending_list;
 101         struct list_head        active_list;
 102         struct mcast_member     *last_join;
 103         int                     members[3];
 104         atomic_t                refcount;
 105         enum mcast_group_state  state;
 106         struct ib_sa_query      *query;
 107         int                     query_id;
 108         u16                     pkey_index;
 109         u8                      leave_state;
 110         int                     retries;
 111 };
 112
 113 struct mcast_member {
 114         struct ib_sa_multicast  multicast;
 115         struct ib_sa_client     *client;
 116         struct mcast_group      *group;
 117         struct list_head        list;
 118         enum mcast_state        state;
 119         atomic_t                refcount;
 120         struct completion       comp;
 121 };
 122
 123 static void join_handler(int status, struct ib_sa_mcmember_rec *rec,
 124                          void *context);
 125 static void leave_handler(int status, struct ib_sa_mcmember_rec *rec,
 126                           void *context);
 127
 128 static struct mcast_group *mcast_find(struct mcast_port *port,
 129                                       union ib_gid *mgid)
 130 {
 131         struct rb_node *node = port->table.rb_node;
 132         struct mcast_group *group;
 133         int ret;
 134
 135         while (node) {
 136                 group = rb_entry(node, struct mcast_group, node);
 137                 ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid);
 138                 if (!ret)
 139                         return group;
 140
 141                 if (ret < 0)
 142                         node = node->rb_left;
 143                 else
 144                         node = node->rb_right;
 145         }
 146         return NULL;
 147 }
 148
 149 static struct mcast_group *mcast_insert(struct mcast_port *port,
 150                                         struct mcast_group *group,
 151                                         int allow_duplicates)
 152 {
 153         struct rb_node **link = &port->table.rb_node;
 154         struct rb_node *parent = NULL;
 155         struct mcast_group *cur_group;
 156         int ret;
 157
 158         while (*link) {
 159                 parent = *link;
 160                 cur_group = rb_entry(parent, struct mcast_group, node);
 161
 162                 ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw,
 163                              sizeof group->rec.mgid);
 164                 if (ret < 0)
 165                         link = &(*link)->rb_left;
 166                 else if (ret > 0)
 167                         link = &(*link)->rb_right;
 168                 else if (allow_duplicates)
 169                         link = &(*link)->rb_left;
 170                 else
 171                         return cur_group;
 172         }
 173         rb_link_node(&group->node, parent, link);
 174         rb_insert_color(&group->node, &port->table);
 175         return NULL;
 176 }
 177
 178 static void deref_port(struct mcast_port *port)
 179 {
 180         if (atomic_dec_and_test(&port->refcount))
 181                 complete(&port->comp);
 182 }
 183
 184 static void release_group(struct mcast_group *group)
 185 {
 186         struct mcast_port *port = group->port;
 187         unsigned long flags;
 188
 189         spin_lock_irqsave(&port->lock, flags);
 190         if (atomic_dec_and_test(&group->refcount)) {
 191                 rb_erase(&group->node, &port->table);
 192                 spin_unlock_irqrestore(&port->lock, flags);
 193                 kfree(group);
 194                 deref_port(port);
 195         } else
 196                 spin_unlock_irqrestore(&port->lock, flags);
 197 }
 198
 199 static void deref_member(struct mcast_member *member)
 200 {
 201         if (atomic_dec_and_test(&member->refcount))
 202                 complete(&member->comp);
 203 }
 204
 205 static void queue_join(struct mcast_member *member)
 206 {
 207         struct mcast_group *group = member->group;
 208         unsigned long flags;
 209
 210         spin_lock_irqsave(&group->lock, flags);
 211         list_add_tail(&member->list, &group->pending_list);
 212         if (group->state == MCAST_IDLE) {
 213                 group->state = MCAST_BUSY;
 214                 atomic_inc(&group->refcount);
 215                 queue_work(mcast_wq, &group->work);
 216         }
 217         spin_unlock_irqrestore(&group->lock, flags);
 218 }
 219
 220 /*
 221  * A multicast group has three types of members: full member, non member, and
 222  * send only member.  We need to keep track of the number of members of each
 223  * type based on their join state.  Adjust the number of members the belong to
 224  * the specified join states.
 225  */
 226 static void adjust_membership(struct mcast_group *group, u8 join_state, int inc)
 227 {
 228         int i;
 229
 230         for (i = 0; i < 3; i++, join_state >>= 1)
 231                 if (join_state & 0x1)
 232                         group->members[i] += inc;
 233 }
 234
 235 /*
 236  * If a multicast group has zero members left for a particular join state, but
 237  * the group is still a member with the SA, we need to leave that join state.
 238  * Determine which join states we still belong to, but that do not have any
 239  * active members.
 240  */
 241 static u8 get_leave_state(struct mcast_group *group)
 242 {
 243         u8 leave_state = 0;
 244         int i;
 245
 246         for (i = 0; i < 3; i++)
 247                 if (!group->members[i])
 248                         leave_state |= (0x1 << i);
 249
 250         return leave_state & group->rec.join_state;
 251 }
 252
 253 static int check_selector(ib_sa_comp_mask comp_mask,
 254                           ib_sa_comp_mask selector_mask,
 255                           ib_sa_comp_mask value_mask,
 256                           u8 selector, u8 src_value, u8 dst_value)
 257 {
 258         int err;
 259
 260         if (!(comp_mask & selector_mask) || !(comp_mask & value_mask))
 261                 return 0;
 262
 263         switch (selector) {
 264         case IB_SA_GT:
 265                 err = (src_value <= dst_value);
 266                 break;
 267         case IB_SA_LT:
 268                 err = (src_value >= dst_value);
 269                 break;
 270         case IB_SA_EQ:
 271                 err = (src_value != dst_value);
 272                 break;
 273         default:
 274                 err = 0;
 275                 break;
 276         }
 277
 278         return err;
 279 }
 280
 281 static int cmp_rec(struct ib_sa_mcmember_rec *src,
 282                    struct ib_sa_mcmember_rec *dst, ib_sa_comp_mask comp_mask)
 283 {
 284         /* MGID must already match */
 285
 286         if (comp_mask & IB_SA_MCMEMBER_REC_PORT_GID &&
 287             memcmp(&src->port_gid, &dst->port_gid, sizeof src->port_gid))
 288                 return -EINVAL;
 289         if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey)
 290                 return -EINVAL;
 291         if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid)
 292                 return -EINVAL;
 293         if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_MTU_SELECTOR,
 294                            IB_SA_MCMEMBER_REC_MTU, dst->mtu_selector,
 295                            src->mtu, dst->mtu))
 296                 return -EINVAL;
 297         if (comp_mask & IB_SA_MCMEMBER_REC_TRAFFIC_CLASS &&
 298             src->traffic_class != dst->traffic_class)
 299                 return -EINVAL;
 300         if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey)
 301                 return -EINVAL;
 302         if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_RATE_SELECTOR,
 303                            IB_SA_MCMEMBER_REC_RATE, dst->rate_selector,
 304                            src->rate, dst->rate))
 305                 return -EINVAL;
 306         if (check_selector(comp_mask,
 307                            IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR,
 308                            IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME,
 309                            dst->packet_life_time_selector,
 310                            src->packet_life_time, dst->packet_life_time))
 311                 return -EINVAL;
 312         if (comp_mask & IB_SA_MCMEMBER_REC_SL && src->sl != dst->sl)
 313                 return -EINVAL;
 314         if (comp_mask & IB_SA_MCMEMBER_REC_FLOW_LABEL &&
 315             src->flow_label != dst->flow_label)
 316                 return -EINVAL;
 317         if (comp_mask & IB_SA_MCMEMBER_REC_HOP_LIMIT &&
 318             src->hop_limit != dst->hop_limit)
 319                 return -EINVAL;
 320         if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE && src->scope != dst->scope)
 321                 return -EINVAL;
 322
 323         /* join_state checked separately, proxy_join ignored */
 324
 325         return 0;
 326 }
 327
 328 static int send_join(struct mcast_group *group, struct mcast_member *member)
 329 {
 330         struct mcast_port *port = group->port;
 331         int ret;
 332
 333         group->last_join = member;
 334         ret = ib_sa_mcmember_rec_query(&sa_client, port->dev->device,
 335                                        port->port_num, IB_MGMT_METHOD_SET,
 336                                        &member->multicast.rec,
 337                                        member->multicast.comp_mask,
 338                                        3000, GFP_KERNEL, join_handler, group,
 339                                        &group->query);
 340         if (ret >= 0) {
 341                 group->query_id = ret;
 342                 ret = 0;
 343         }
 344         return ret;
 345 }
 346
 347 static int send_leave(struct mcast_group *group, u8 leave_state)
 348 {
 349         struct mcast_port *port = group->port;
 350         struct ib_sa_mcmember_rec rec;
 351         int ret;
 352
 353         rec = group->rec;
 354         rec.join_state = leave_state;
 355         group->leave_state = leave_state;
 356
 357         ret = ib_sa_mcmember_rec_query(&sa_client, port->dev->device,
 358                                        port->port_num, IB_SA_METHOD_DELETE, &rec,
 359                                        IB_SA_MCMEMBER_REC_MGID     |
 360                                        IB_SA_MCMEMBER_REC_PORT_GID |
 361                                        IB_SA_MCMEMBER_REC_JOIN_STATE,
 362                                        3000, GFP_KERNEL, leave_handler,
 363                                        group, &group->query);
 364         if (ret >= 0) {
 365                 group->query_id = ret;
 366                 ret = 0;
 367         }
 368         return 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                 ib_find_pkey(group->port->dev->device, group->port->port_num,
 527                              be16_to_cpu(rec->pkey), &pkey_index);
 528
 529                 spin_lock_irq(&group->port->lock);
 530                 group->rec = *rec;
 531                 if (group->state == MCAST_BUSY &&
 532                     group->pkey_index == MCAST_INVALID_PKEY_INDEX)
 533                         group->pkey_index = pkey_index;
 534                 if (!memcmp(&mgid0, &group->rec.mgid, sizeof mgid0)) {
 535                         rb_erase(&group->node, &group->port->table);
 536                         mcast_insert(group->port, group, 1);
 537                 }
 538                 spin_unlock_irq(&group->port->lock);
 539         }
 540         mcast_work_handler(&group->work);
 541 }
 542
 543 static void leave_handler(int status, struct ib_sa_mcmember_rec *rec,
 544                           void *context)
 545 {
 546         struct mcast_group *group = context;
 547
 548         if (status && group->retries > 0 &&
 549             !send_leave(group, group->leave_state))
 550                 group->retries--;
 551         else
 552                 mcast_work_handler(&group->work);
 553 }
 554
 555 static struct mcast_group *acquire_group(struct mcast_port *port,
 556                                          union ib_gid *mgid, gfp_t gfp_mask)
 557 {
 558         struct mcast_group *group, *cur_group;
 559         unsigned long flags;
 560         int is_mgid0;
 561
 562         is_mgid0 = !memcmp(&mgid0, mgid, sizeof mgid0);
 563         if (!is_mgid0) {
 564                 spin_lock_irqsave(&port->lock, flags);
 565                 group = mcast_find(port, mgid);
 566                 if (group)
 567                         goto found;
 568                 spin_unlock_irqrestore(&port->lock, flags);
 569         }
 570
 571         group = kzalloc(sizeof *group, gfp_mask);
 572         if (!group)
 573                 return NULL;
 574
 575         group->retries = 3;
 576         group->port = port;
 577         group->rec.mgid = *mgid;
 578         group->pkey_index = MCAST_INVALID_PKEY_INDEX;
 579         INIT_LIST_HEAD(&group->pending_list);
 580         INIT_LIST_HEAD(&group->active_list);
 581         INIT_WORK(&group->work, mcast_work_handler);
 582         spin_lock_init(&group->lock);
 583
 584         spin_lock_irqsave(&port->lock, flags);
 585         cur_group = mcast_insert(port, group, is_mgid0);
 586         if (cur_group) {
 587                 kfree(group);
 588                 group = cur_group;
 589         } else
 590                 atomic_inc(&port->refcount);
 591 found:
 592         atomic_inc(&group->refcount);
 593         spin_unlock_irqrestore(&port->lock, flags);
 594         return group;
 595 }
 596
 597 /*
 598  * We serialize all join requests to a single group to make our lives much
 599  * easier.  Otherwise, two users could try to join the same group
 600  * simultaneously, with different configurations, one could leave while the
 601  * join is in progress, etc., which makes locking around error recovery
 602  * difficult.
 603  */
 604 struct ib_sa_multicast *
 605 ib_sa_join_multicast(struct ib_sa_client *client,
 606                      struct ib_device *device, u8 port_num,
 607                      struct ib_sa_mcmember_rec *rec,
 608                      ib_sa_comp_mask comp_mask, gfp_t gfp_mask,
 609                      int (*callback)(int status,
 610                                      struct ib_sa_multicast *multicast),
 611                      void *context)
 612 {
 613         struct mcast_device *dev;
 614         struct mcast_member *member;
 615         struct ib_sa_multicast *multicast;
 616         int ret;
 617
 618         dev = ib_get_client_data(device, &mcast_client);
 619         if (!dev)
 620                 return ERR_PTR(-ENODEV);
 621
 622         member = kmalloc(sizeof *member, gfp_mask);
 623         if (!member)
 624                 return ERR_PTR(-ENOMEM);
 625
 626         ib_sa_client_get(client);
 627         member->client = client;
 628         member->multicast.rec = *rec;
 629         member->multicast.comp_mask = comp_mask;
 630         member->multicast.callback = callback;
 631         member->multicast.context = context;
 632         init_completion(&member->comp);
 633         atomic_set(&member->refcount, 1);
 634         member->state = MCAST_JOINING;
 635
 636         member->group = acquire_group(&dev->port[port_num - dev->start_port],
 637                                       &rec->mgid, gfp_mask);
 638         if (!member->group) {
 639                 ret = -ENOMEM;
 640                 goto err;
 641         }
 642
 643         /*
 644          * The user will get the multicast structure in their callback.  They
 645          * could then free the multicast structure before we can return from
 646          * this routine.  So we save the pointer to return before queuing
 647          * any callback.
 648          */
 649         multicast = &member->multicast;
 650         queue_join(member);
 651         return multicast;
 652
 653 err:
 654         ib_sa_client_put(client);
 655         kfree(member);
 656         return ERR_PTR(ret);
 657 }
 658 EXPORT_SYMBOL(ib_sa_join_multicast);
 659
 660 void ib_sa_free_multicast(struct ib_sa_multicast *multicast)
 661 {
 662         struct mcast_member *member;
 663         struct mcast_group *group;
 664
 665         member = container_of(multicast, struct mcast_member, multicast);
 666         group = member->group;
 667
 668         spin_lock_irq(&group->lock);
 669         if (member->state == MCAST_MEMBER)
 670                 adjust_membership(group, multicast->rec.join_state, -1);
 671
 672         list_del_init(&member->list);
 673
 674         if (group->state == MCAST_IDLE) {
 675                 group->state = MCAST_BUSY;
 676                 spin_unlock_irq(&group->lock);
 677                 /* Continue to hold reference on group until callback */
 678                 queue_work(mcast_wq, &group->work);
 679         } else {
 680                 spin_unlock_irq(&group->lock);
 681                 release_group(group);
 682         }
 683
 684         deref_member(member);
 685         wait_for_completion(&member->comp);
 686         ib_sa_client_put(member->client);
 687         kfree(member);
 688 }
 689 EXPORT_SYMBOL(ib_sa_free_multicast);
 690
 691 int ib_sa_get_mcmember_rec(struct ib_device *device, u8 port_num,
 692                            union ib_gid *mgid, struct ib_sa_mcmember_rec *rec)
 693 {
 694         struct mcast_device *dev;
 695         struct mcast_port *port;
 696         struct mcast_group *group;
 697         unsigned long flags;
 698         int ret = 0;
 699
 700         dev = ib_get_client_data(device, &mcast_client);
 701         if (!dev)
 702                 return -ENODEV;
 703
 704         port = &dev->port[port_num - dev->start_port];
 705         spin_lock_irqsave(&port->lock, flags);
 706         group = mcast_find(port, mgid);
 707         if (group)
 708                 *rec = group->rec;
 709         else
 710                 ret = -EADDRNOTAVAIL;
 711         spin_unlock_irqrestore(&port->lock, flags);
 712
 713         return ret;
 714 }
 715 EXPORT_SYMBOL(ib_sa_get_mcmember_rec);
 716
 717 int ib_init_ah_from_mcmember(struct ib_device *device, u8 port_num,
 718                              struct ib_sa_mcmember_rec *rec,
 719                              struct ib_ah_attr *ah_attr)
 720 {
 721         int ret;
 722         u16 gid_index;
 723         u8 p;
 724
 725         ret = ib_find_cached_gid(device, &rec->port_gid, &p, &gid_index);
 726         if (ret)
 727                 return ret;
 728
 729         memset(ah_attr, 0, sizeof *ah_attr);
 730         ah_attr->dlid = be16_to_cpu(rec->mlid);
 731         ah_attr->sl = rec->sl;
 732         ah_attr->port_num = port_num;
 733         ah_attr->static_rate = rec->rate;
 734
 735         ah_attr->ah_flags = IB_AH_GRH;
 736         ah_attr->grh.dgid = rec->mgid;
 737
 738         ah_attr->grh.sgid_index = (u8) gid_index;
 739         ah_attr->grh.flow_label = be32_to_cpu(rec->flow_label);
 740         ah_attr->grh.hop_limit = rec->hop_limit;
 741         ah_attr->grh.traffic_class = rec->traffic_class;
 742
 743         return 0;
 744 }
 745 EXPORT_SYMBOL(ib_init_ah_from_mcmember);
 746
 747 static void mcast_groups_event(struct mcast_port *port,
 748                                enum mcast_group_state state)
 749 {
 750         struct mcast_group *group;
 751         struct rb_node *node;
 752         unsigned long flags;
 753
 754         spin_lock_irqsave(&port->lock, flags);
 755         for (node = rb_first(&port->table); node; node = rb_next(node)) {
 756                 group = rb_entry(node, struct mcast_group, node);
 757                 spin_lock(&group->lock);
 758                 if (group->state == MCAST_IDLE) {
 759                         atomic_inc(&group->refcount);
 760                         queue_work(mcast_wq, &group->work);
 761                 }
 762                 if (group->state != MCAST_GROUP_ERROR)
 763                         group->state = state;
 764                 spin_unlock(&group->lock);
 765         }
 766         spin_unlock_irqrestore(&port->lock, flags);
 767 }
 768
 769 static void mcast_event_handler(struct ib_event_handler *handler,
 770                                 struct ib_event *event)
 771 {
 772         struct mcast_device *dev;
 773         int index;
 774
 775         dev = container_of(handler, struct mcast_device, event_handler);
 776         index = event->element.port_num - dev->start_port;
 777
 778         switch (event->event) {
 779         case IB_EVENT_PORT_ERR:
 780         case IB_EVENT_LID_CHANGE:
 781         case IB_EVENT_SM_CHANGE:
 782         case IB_EVENT_CLIENT_REREGISTER:
 783                 mcast_groups_event(&dev->port[index], MCAST_GROUP_ERROR);
 784                 break;
 785         case IB_EVENT_PKEY_CHANGE:
 786                 mcast_groups_event(&dev->port[index], MCAST_PKEY_EVENT);
 787                 break;
 788         default:
 789                 break;
 790         }
 791 }
 792
 793 static void mcast_add_one(struct ib_device *device)
 794 {
 795         struct mcast_device *dev;
 796         struct mcast_port *port;
 797         int i;
 798
 799         if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
 800                 return;
 801
 802         dev = kmalloc(sizeof *dev + device->phys_port_cnt * sizeof *port,
 803                       GFP_KERNEL);
 804         if (!dev)
 805                 return;
 806
 807         if (device->node_type == RDMA_NODE_IB_SWITCH)
 808                 dev->start_port = dev->end_port = 0;
 809         else {
 810                 dev->start_port = 1;
 811                 dev->end_port = device->phys_port_cnt;
 812         }
 813
 814         for (i = 0; i <= dev->end_port - dev->start_port; i++) {
 815                 port = &dev->port[i];
 816                 port->dev = dev;
 817                 port->port_num = dev->start_port + i;
 818                 spin_lock_init(&port->lock);
 819                 port->table = RB_ROOT;
 820                 init_completion(&port->comp);
 821                 atomic_set(&port->refcount, 1);
 822         }
 823
 824         dev->device = device;
 825         ib_set_client_data(device, &mcast_client, dev);
 826
 827         INIT_IB_EVENT_HANDLER(&dev->event_handler, device, mcast_event_handler);
 828         ib_register_event_handler(&dev->event_handler);
 829 }
 830
 831 static void mcast_remove_one(struct ib_device *device)
 832 {
 833         struct mcast_device *dev;
 834         struct mcast_port *port;
 835         int i;
 836
 837         dev = ib_get_client_data(device, &mcast_client);
 838         if (!dev)
 839                 return;
 840
 841         ib_unregister_event_handler(&dev->event_handler);
 842         flush_workqueue(mcast_wq);
 843
 844         for (i = 0; i <= dev->end_port - dev->start_port; i++) {
 845                 port = &dev->port[i];
 846                 deref_port(port);
 847                 wait_for_completion(&port->comp);
 848         }
 849
 850         kfree(dev);
 851 }
 852
 853 int mcast_init(void)
 854 {
 855         int ret;
 856
 857         mcast_wq = create_singlethread_workqueue("ib_mcast");
 858         if (!mcast_wq)
 859                 return -ENOMEM;
 860
 861         ib_sa_register_client(&sa_client);
 862
 863         ret = ib_register_client(&mcast_client);
 864         if (ret)
 865                 goto err;
 866         return 0;
 867
 868 err:
 869         ib_sa_unregister_client(&sa_client);
 870         destroy_workqueue(mcast_wq);
 871         return ret;
 872 }
 873
 874 void mcast_cleanup(void)
 875 {
 876         ib_unregister_client(&mcast_client);
 877         ib_sa_unregister_client(&sa_client);
 878         destroy_workqueue(mcast_wq);
 879 }