1255932Salfred/* 2255932Salfred * Copyright (c) 2012 Mellanox Technologies. All rights reserved. 3255932Salfred * 4255932Salfred * This software is available to you under a choice of one of two 5255932Salfred * licenses. You may choose to be licensed under the terms of the GNU 6255932Salfred * General Public License (GPL) Version 2, available from the file 7255932Salfred * COPYING in the main directory of this source tree, or the 8255932Salfred * OpenIB.org BSD license below: 9255932Salfred * 10255932Salfred * Redistribution and use in source and binary forms, with or 11255932Salfred * without modification, are permitted provided that the following 12255932Salfred * conditions are met: 13255932Salfred * 14255932Salfred * - Redistributions of source code must retain the above 15255932Salfred * copyright notice, this list of conditions and the following 16255932Salfred * disclaimer. 17255932Salfred * 18255932Salfred * - Redistributions in binary form must reproduce the above 19255932Salfred * copyright notice, this list of conditions and the following 20255932Salfred * disclaimer in the documentation and/or other materials 21255932Salfred * provided with the distribution. 22255932Salfred * 23255932Salfred * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24255932Salfred * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25255932Salfred * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26255932Salfred * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27255932Salfred * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28255932Salfred * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29255932Salfred * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30255932Salfred * SOFTWARE. 31255932Salfred */ 32255932Salfred 33255932Salfred#include <rdma/ib_mad.h> 34255932Salfred#include <rdma/ib_smi.h> 35255932Salfred#include <rdma/ib_cache.h> 36255932Salfred#include <rdma/ib_sa.h> 37255932Salfred 38255932Salfred#include <linux/mlx4/cmd.h> 39255932Salfred#include <linux/delay.h> 40255932Salfred 41255932Salfred#include "mlx4_ib.h" 42255932Salfred 43255932Salfred#define MAX_VFS 80 44255932Salfred#define MAX_PEND_REQS_PER_FUNC 4 45255932Salfred#define MAD_TIMEOUT_MS 2000 46255932Salfred 47255932Salfred#define mcg_warn(fmt, arg...) pr_warn("MCG WARNING: " fmt, ##arg) 48255932Salfred#define mcg_error(fmt, arg...) pr_err(fmt, ##arg) 49255932Salfred#define mcg_warn_group(group, format, arg...) \ 50255932Salfred pr_warn("%s-%d: %16s (port %d): WARNING: " format, __func__, __LINE__,\ 51255932Salfred (group)->name, group->demux->port, ## arg) 52255932Salfred 53255932Salfred#define mcg_error_group(group, format, arg...) \ 54255932Salfred pr_err(" %16s: " format, (group)->name, ## arg) 55255932Salfred 56255932Salfredstatic union ib_gid mgid0; 57255932Salfred 58255932Salfredstatic struct workqueue_struct *clean_wq; 59255932Salfred 60255932Salfredenum mcast_state { 61255932Salfred MCAST_NOT_MEMBER = 0, 62255932Salfred MCAST_MEMBER, 63255932Salfred}; 64255932Salfred 65255932Salfredenum mcast_group_state { 66255932Salfred MCAST_IDLE, 67255932Salfred MCAST_JOIN_SENT, 68255932Salfred MCAST_LEAVE_SENT, 69255932Salfred MCAST_RESP_READY 70255932Salfred}; 71255932Salfred 72255932Salfredstruct mcast_member { 73255932Salfred enum mcast_state state; 74255932Salfred uint8_t join_state; 75255932Salfred int num_pend_reqs; 76255932Salfred struct list_head pending; 77255932Salfred}; 78255932Salfred 79255932Salfredstruct ib_sa_mcmember_data { 80255932Salfred union ib_gid mgid; 81255932Salfred union ib_gid port_gid; 82255932Salfred __be32 qkey; 83255932Salfred __be16 mlid; 84255932Salfred u8 mtusel_mtu; 85255932Salfred u8 tclass; 86255932Salfred __be16 pkey; 87255932Salfred u8 ratesel_rate; 88255932Salfred u8 lifetmsel_lifetm; 89255932Salfred __be32 sl_flowlabel_hoplimit; 90255932Salfred u8 scope_join_state; 91255932Salfred u8 proxy_join; 92255932Salfred u8 reserved[2]; 93255932Salfred}; 94255932Salfred 95255932Salfredstruct mcast_group { 96255932Salfred struct ib_sa_mcmember_data rec; 97255932Salfred struct rb_node node; 98255932Salfred struct list_head mgid0_list; 99255932Salfred struct mlx4_ib_demux_ctx *demux; 100255932Salfred struct mcast_member func[MAX_VFS]; 101255932Salfred struct mutex lock; 102255932Salfred struct work_struct work; 103255932Salfred struct list_head pending_list; 104255932Salfred int members[3]; 105255932Salfred enum mcast_group_state state; 106255932Salfred enum mcast_group_state prev_state; 107255932Salfred struct ib_sa_mad response_sa_mad; 108255932Salfred __be64 last_req_tid; 109255932Salfred 110255932Salfred char name[33]; /* MGID string */ 111255932Salfred struct device_attribute dentry; 112255932Salfred 113255932Salfred /* refcount is the reference count for the following: 114255932Salfred 1. Each queued request 115255932Salfred 2. Each invocation of the worker thread 116255932Salfred 3. Membership of the port at the SA 117255932Salfred */ 118255932Salfred atomic_t refcount; 119255932Salfred 120255932Salfred /* delayed work to clean pending SM request */ 121255932Salfred struct delayed_work timeout_work; 122255932Salfred struct list_head cleanup_list; 123255932Salfred}; 124255932Salfred 125255932Salfredstruct mcast_req { 126255932Salfred int func; 127255932Salfred struct ib_sa_mad sa_mad; 128255932Salfred struct list_head group_list; 129255932Salfred struct list_head func_list; 130255932Salfred struct mcast_group *group; 131255932Salfred int clean; 132255932Salfred}; 133255932Salfred 134255932Salfred 135255932Salfred#define safe_atomic_dec(ref) \ 136255932Salfred do {\ 137255932Salfred if (atomic_dec_and_test(ref)) \ 138255932Salfred mcg_warn_group(group, "did not expect to reach zero\n"); \ 139255932Salfred } while (0) 140255932Salfred 141255932Salfredstatic const char *get_state_string(enum mcast_group_state state) 142255932Salfred{ 143255932Salfred switch (state) { 144255932Salfred case MCAST_IDLE: 145255932Salfred return "MCAST_IDLE"; 146255932Salfred case MCAST_JOIN_SENT: 147255932Salfred return "MCAST_JOIN_SENT"; 148255932Salfred case MCAST_LEAVE_SENT: 149255932Salfred return "MCAST_LEAVE_SENT"; 150255932Salfred case MCAST_RESP_READY: 151255932Salfred return "MCAST_RESP_READY"; 152255932Salfred } 153255932Salfred return "Invalid State"; 154255932Salfred} 155255932Salfred 156255932Salfredstatic struct mcast_group *mcast_find(struct mlx4_ib_demux_ctx *ctx, 157255932Salfred union ib_gid *mgid) 158255932Salfred{ 159255932Salfred struct rb_node *node = ctx->mcg_table.rb_node; 160255932Salfred struct mcast_group *group; 161255932Salfred int ret; 162255932Salfred 163255932Salfred while (node) { 164255932Salfred group = rb_entry(node, struct mcast_group, node); 165255932Salfred ret = memcmp(mgid->raw, group->rec.mgid.raw, sizeof *mgid); 166255932Salfred if (!ret) 167255932Salfred return group; 168255932Salfred 169255932Salfred if (ret < 0) 170255932Salfred node = node->rb_left; 171255932Salfred else 172255932Salfred node = node->rb_right; 173255932Salfred } 174255932Salfred return NULL; 175255932Salfred} 176255932Salfred 177255932Salfredstatic struct mcast_group *mcast_insert(struct mlx4_ib_demux_ctx *ctx, 178255932Salfred struct mcast_group *group) 179255932Salfred{ 180255932Salfred struct rb_node **link = &ctx->mcg_table.rb_node; 181255932Salfred struct rb_node *parent = NULL; 182255932Salfred struct mcast_group *cur_group; 183255932Salfred int ret; 184255932Salfred 185255932Salfred while (*link) { 186255932Salfred parent = *link; 187255932Salfred cur_group = rb_entry(parent, struct mcast_group, node); 188255932Salfred 189255932Salfred ret = memcmp(group->rec.mgid.raw, cur_group->rec.mgid.raw, 190255932Salfred sizeof group->rec.mgid); 191255932Salfred if (ret < 0) 192255932Salfred link = &(*link)->rb_left; 193255932Salfred else if (ret > 0) 194255932Salfred link = &(*link)->rb_right; 195255932Salfred else 196255932Salfred return cur_group; 197255932Salfred } 198255932Salfred rb_link_node(&group->node, parent, link); 199255932Salfred rb_insert_color(&group->node, &ctx->mcg_table); 200255932Salfred return NULL; 201255932Salfred} 202255932Salfred 203255932Salfredstatic int send_mad_to_wire(struct mlx4_ib_demux_ctx *ctx, struct ib_mad *mad) 204255932Salfred{ 205255932Salfred struct mlx4_ib_dev *dev = ctx->dev; 206255932Salfred struct ib_ah_attr ah_attr; 207255932Salfred 208255932Salfred spin_lock(&dev->sm_lock); 209255932Salfred if (!dev->sm_ah[ctx->port - 1]) { 210255932Salfred /* port is not yet Active, sm_ah not ready */ 211255932Salfred spin_unlock(&dev->sm_lock); 212255932Salfred return -EAGAIN; 213255932Salfred } 214255932Salfred mlx4_ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr); 215255932Salfred spin_unlock(&dev->sm_lock); 216255932Salfred return mlx4_ib_send_to_wire(dev, mlx4_master_func_num(dev->dev), ctx->port, 217255932Salfred IB_QPT_GSI, 0, 1, IB_QP1_QKEY, &ah_attr, mad); 218255932Salfred} 219255932Salfred 220255932Salfredstatic int send_mad_to_slave(int slave, struct mlx4_ib_demux_ctx *ctx, 221255932Salfred struct ib_mad *mad) 222255932Salfred{ 223255932Salfred struct mlx4_ib_dev *dev = ctx->dev; 224255932Salfred struct ib_mad_agent *agent = dev->send_agent[ctx->port - 1][1]; 225255932Salfred struct ib_wc wc; 226255932Salfred struct ib_ah_attr ah_attr; 227255932Salfred 228255932Salfred /* Our agent might not yet be registered when mads start to arrive */ 229255932Salfred if (!agent) 230255932Salfred return -EAGAIN; 231255932Salfred 232255932Salfred ib_query_ah(dev->sm_ah[ctx->port - 1], &ah_attr); 233255932Salfred 234255932Salfred if (ib_find_cached_pkey(&dev->ib_dev, ctx->port, IB_DEFAULT_PKEY_FULL, &wc.pkey_index)) 235255932Salfred return -EINVAL; 236255932Salfred wc.sl = 0; 237255932Salfred wc.dlid_path_bits = 0; 238255932Salfred wc.port_num = ctx->port; 239255932Salfred wc.slid = ah_attr.dlid; /* opensm lid */ 240255932Salfred wc.src_qp = 1; 241255932Salfred return mlx4_ib_send_to_slave(dev, slave, ctx->port, IB_QPT_GSI, &wc, NULL, mad); 242255932Salfred} 243255932Salfred 244255932Salfredstatic int send_join_to_wire(struct mcast_group *group, struct ib_sa_mad *sa_mad) 245255932Salfred{ 246255932Salfred struct ib_sa_mad mad; 247255932Salfred struct ib_sa_mcmember_data *sa_mad_data = (struct ib_sa_mcmember_data *)&mad.data; 248255932Salfred int ret; 249255932Salfred 250255932Salfred /* we rely on a mad request as arrived from a VF */ 251255932Salfred memcpy(&mad, sa_mad, sizeof mad); 252255932Salfred 253255932Salfred /* fix port GID to be the real one (slave 0) */ 254255932Salfred sa_mad_data->port_gid.global.interface_id = group->demux->guid_cache[0]; 255255932Salfred 256255932Salfred /* assign our own TID */ 257255932Salfred mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux); 258255932Salfred group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */ 259255932Salfred 260255932Salfred ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad); 261255932Salfred /* set timeout handler */ 262255932Salfred if (!ret) { 263255932Salfred /* calls mlx4_ib_mcg_timeout_handler */ 264255932Salfred queue_delayed_work(group->demux->mcg_wq, &group->timeout_work, 265255932Salfred msecs_to_jiffies(MAD_TIMEOUT_MS)); 266255932Salfred } 267255932Salfred 268255932Salfred return ret; 269255932Salfred} 270255932Salfred 271255932Salfredstatic int send_leave_to_wire(struct mcast_group *group, u8 join_state) 272255932Salfred{ 273255932Salfred struct ib_sa_mad mad; 274255932Salfred struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data; 275255932Salfred int ret; 276255932Salfred 277255932Salfred memset(&mad, 0, sizeof mad); 278255932Salfred mad.mad_hdr.base_version = 1; 279255932Salfred mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM; 280255932Salfred mad.mad_hdr.class_version = 2; 281255932Salfred mad.mad_hdr.method = IB_SA_METHOD_DELETE; 282255932Salfred mad.mad_hdr.status = cpu_to_be16(0); 283255932Salfred mad.mad_hdr.class_specific = cpu_to_be16(0); 284255932Salfred mad.mad_hdr.tid = mlx4_ib_get_new_demux_tid(group->demux); 285255932Salfred group->last_req_tid = mad.mad_hdr.tid; /* keep it for later validation */ 286255932Salfred mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC); 287255932Salfred mad.mad_hdr.attr_mod = cpu_to_be32(0); 288255932Salfred mad.sa_hdr.sm_key = 0x0; 289255932Salfred mad.sa_hdr.attr_offset = cpu_to_be16(7); 290255932Salfred mad.sa_hdr.comp_mask = IB_SA_MCMEMBER_REC_MGID | 291255932Salfred IB_SA_MCMEMBER_REC_PORT_GID | IB_SA_MCMEMBER_REC_JOIN_STATE; 292255932Salfred 293255932Salfred *sa_data = group->rec; 294255932Salfred sa_data->scope_join_state = join_state; 295255932Salfred 296255932Salfred ret = send_mad_to_wire(group->demux, (struct ib_mad *)&mad); 297255932Salfred if (ret) 298255932Salfred group->state = MCAST_IDLE; 299255932Salfred 300255932Salfred /* set timeout handler */ 301255932Salfred if (!ret) { 302255932Salfred /* calls mlx4_ib_mcg_timeout_handler */ 303255932Salfred queue_delayed_work(group->demux->mcg_wq, &group->timeout_work, 304255932Salfred msecs_to_jiffies(MAD_TIMEOUT_MS)); 305255932Salfred } 306255932Salfred 307255932Salfred return ret; 308255932Salfred} 309255932Salfred 310255932Salfredstatic int send_reply_to_slave(int slave, struct mcast_group *group, 311255932Salfred struct ib_sa_mad *req_sa_mad, u16 status) 312255932Salfred{ 313255932Salfred struct ib_sa_mad mad; 314255932Salfred struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)&mad.data; 315255932Salfred struct ib_sa_mcmember_data *req_sa_data = (struct ib_sa_mcmember_data *)&req_sa_mad->data; 316255932Salfred int ret; 317255932Salfred 318255932Salfred memset(&mad, 0, sizeof mad); 319255932Salfred mad.mad_hdr.base_version = 1; 320255932Salfred mad.mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM; 321255932Salfred mad.mad_hdr.class_version = 2; 322255932Salfred mad.mad_hdr.method = IB_MGMT_METHOD_GET_RESP; 323255932Salfred mad.mad_hdr.status = cpu_to_be16(status); 324255932Salfred mad.mad_hdr.class_specific = cpu_to_be16(0); 325255932Salfred mad.mad_hdr.tid = req_sa_mad->mad_hdr.tid; 326255932Salfred *(u8 *)&mad.mad_hdr.tid = 0; /* resetting tid to 0 */ 327255932Salfred mad.mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC); 328255932Salfred mad.mad_hdr.attr_mod = cpu_to_be32(0); 329255932Salfred mad.sa_hdr.sm_key = req_sa_mad->sa_hdr.sm_key; 330255932Salfred mad.sa_hdr.attr_offset = cpu_to_be16(7); 331255932Salfred mad.sa_hdr.comp_mask = 0; /* ignored on responses, see IBTA spec */ 332255932Salfred 333255932Salfred *sa_data = group->rec; 334255932Salfred 335255932Salfred /* reconstruct VF's requested join_state and port_gid */ 336255932Salfred sa_data->scope_join_state &= 0xf0; 337255932Salfred sa_data->scope_join_state |= (group->func[slave].join_state & 0x0f); 338255932Salfred memcpy(&sa_data->port_gid, &req_sa_data->port_gid, sizeof req_sa_data->port_gid); 339255932Salfred 340255932Salfred ret = send_mad_to_slave(slave, group->demux, (struct ib_mad *)&mad); 341255932Salfred return ret; 342255932Salfred} 343255932Salfred 344255932Salfredstatic int check_selector(ib_sa_comp_mask comp_mask, 345255932Salfred ib_sa_comp_mask selector_mask, 346255932Salfred ib_sa_comp_mask value_mask, 347255932Salfred u8 src_value, u8 dst_value) 348255932Salfred{ 349255932Salfred int err; 350255932Salfred u8 selector = dst_value >> 6; 351255932Salfred dst_value &= 0x3f; 352255932Salfred src_value &= 0x3f; 353255932Salfred 354255932Salfred if (!(comp_mask & selector_mask) || !(comp_mask & value_mask)) 355255932Salfred return 0; 356255932Salfred 357255932Salfred switch (selector) { 358255932Salfred case IB_SA_GT: 359255932Salfred err = (src_value <= dst_value); 360255932Salfred break; 361255932Salfred case IB_SA_LT: 362255932Salfred err = (src_value >= dst_value); 363255932Salfred break; 364255932Salfred case IB_SA_EQ: 365255932Salfred err = (src_value != dst_value); 366255932Salfred break; 367255932Salfred default: 368255932Salfred err = 0; 369255932Salfred break; 370255932Salfred } 371255932Salfred 372255932Salfred return err; 373255932Salfred} 374255932Salfred 375255932Salfredstatic u16 cmp_rec(struct ib_sa_mcmember_data *src, 376255932Salfred struct ib_sa_mcmember_data *dst, ib_sa_comp_mask comp_mask) 377255932Salfred{ 378255932Salfred /* src is group record, dst is request record */ 379255932Salfred /* MGID must already match */ 380255932Salfred /* Port_GID we always replace to our Port_GID, so it is a match */ 381255932Salfred 382255932Salfred#define MAD_STATUS_REQ_INVALID 0x0200 383255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_QKEY && src->qkey != dst->qkey) 384255932Salfred return MAD_STATUS_REQ_INVALID; 385255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_MLID && src->mlid != dst->mlid) 386255932Salfred return MAD_STATUS_REQ_INVALID; 387255932Salfred if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_MTU_SELECTOR, 388255932Salfred IB_SA_MCMEMBER_REC_MTU, 389255932Salfred src->mtusel_mtu, dst->mtusel_mtu)) 390255932Salfred return MAD_STATUS_REQ_INVALID; 391255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_TRAFFIC_CLASS && 392255932Salfred src->tclass != dst->tclass) 393255932Salfred return MAD_STATUS_REQ_INVALID; 394255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_PKEY && src->pkey != dst->pkey) 395255932Salfred return MAD_STATUS_REQ_INVALID; 396255932Salfred if (check_selector(comp_mask, IB_SA_MCMEMBER_REC_RATE_SELECTOR, 397255932Salfred IB_SA_MCMEMBER_REC_RATE, 398255932Salfred src->ratesel_rate, dst->ratesel_rate)) 399255932Salfred return MAD_STATUS_REQ_INVALID; 400255932Salfred if (check_selector(comp_mask, 401255932Salfred IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME_SELECTOR, 402255932Salfred IB_SA_MCMEMBER_REC_PACKET_LIFE_TIME, 403255932Salfred src->lifetmsel_lifetm, dst->lifetmsel_lifetm)) 404255932Salfred return MAD_STATUS_REQ_INVALID; 405255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_SL && 406255932Salfred (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0xf0000000) != 407255932Salfred (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0xf0000000)) 408255932Salfred return MAD_STATUS_REQ_INVALID; 409255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_FLOW_LABEL && 410255932Salfred (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x0fffff00) != 411255932Salfred (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x0fffff00)) 412255932Salfred return MAD_STATUS_REQ_INVALID; 413255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_HOP_LIMIT && 414255932Salfred (be32_to_cpu(src->sl_flowlabel_hoplimit) & 0x000000ff) != 415255932Salfred (be32_to_cpu(dst->sl_flowlabel_hoplimit) & 0x000000ff)) 416255932Salfred return MAD_STATUS_REQ_INVALID; 417255932Salfred if (comp_mask & IB_SA_MCMEMBER_REC_SCOPE && 418255932Salfred (src->scope_join_state & 0xf0) != 419255932Salfred (dst->scope_join_state & 0xf0)) 420255932Salfred return MAD_STATUS_REQ_INVALID; 421255932Salfred 422255932Salfred /* join_state checked separately, proxy_join ignored */ 423255932Salfred 424255932Salfred return 0; 425255932Salfred} 426255932Salfred 427255932Salfred/* release group, return 1 if this was last release and group is destroyed 428255932Salfred * timout work is canceled sync */ 429255932Salfredstatic int release_group(struct mcast_group *group, int from_timeout_handler) 430255932Salfred{ 431255932Salfred struct mlx4_ib_demux_ctx *ctx = group->demux; 432255932Salfred int nzgroup; 433255932Salfred 434255932Salfred mutex_lock(&ctx->mcg_table_lock); 435255932Salfred mutex_lock(&group->lock); 436255932Salfred if (atomic_dec_and_test(&group->refcount)) { 437255932Salfred if (!from_timeout_handler) { 438255932Salfred if (group->state != MCAST_IDLE && 439255932Salfred !cancel_delayed_work(&group->timeout_work)) { 440255932Salfred atomic_inc(&group->refcount); 441255932Salfred mutex_unlock(&group->lock); 442255932Salfred mutex_unlock(&ctx->mcg_table_lock); 443255932Salfred return 0; 444255932Salfred } 445255932Salfred } 446255932Salfred 447255932Salfred nzgroup = memcmp(&group->rec.mgid, &mgid0, sizeof mgid0); 448255932Salfred if (nzgroup) 449255932Salfred del_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr); 450255932Salfred if (!list_empty(&group->pending_list)) 451255932Salfred mcg_warn_group(group, "releasing a group with non empty pending list\n"); 452255932Salfred if (nzgroup) 453255932Salfred rb_erase(&group->node, &ctx->mcg_table); 454255932Salfred list_del_init(&group->mgid0_list); 455255932Salfred mutex_unlock(&group->lock); 456255932Salfred mutex_unlock(&ctx->mcg_table_lock); 457255932Salfred kfree(group); 458255932Salfred return 1; 459255932Salfred } else { 460255932Salfred mutex_unlock(&group->lock); 461255932Salfred mutex_unlock(&ctx->mcg_table_lock); 462255932Salfred } 463255932Salfred return 0; 464255932Salfred} 465255932Salfred 466255932Salfredstatic void adjust_membership(struct mcast_group *group, u8 join_state, int inc) 467255932Salfred{ 468255932Salfred int i; 469255932Salfred 470255932Salfred for (i = 0; i < 3; i++, join_state >>= 1) 471255932Salfred if (join_state & 0x1) 472255932Salfred group->members[i] += inc; 473255932Salfred} 474255932Salfred 475255932Salfredstatic u8 get_leave_state(struct mcast_group *group) 476255932Salfred{ 477255932Salfred u8 leave_state = 0; 478255932Salfred int i; 479255932Salfred 480255932Salfred for (i = 0; i < 3; i++) 481255932Salfred if (!group->members[i]) 482255932Salfred leave_state |= (1 << i); 483255932Salfred 484255932Salfred return leave_state & (group->rec.scope_join_state & 7); 485255932Salfred} 486255932Salfred 487255932Salfredstatic int join_group(struct mcast_group *group, int slave, u8 join_mask) 488255932Salfred{ 489255932Salfred int ret = 0; 490255932Salfred u8 join_state; 491255932Salfred 492255932Salfred /* remove bits that slave is already member of, and adjust */ 493255932Salfred join_state = join_mask & (~group->func[slave].join_state); 494255932Salfred adjust_membership(group, join_state, 1); 495255932Salfred group->func[slave].join_state |= join_state; 496255932Salfred if (group->func[slave].state != MCAST_MEMBER && join_state) { 497255932Salfred group->func[slave].state = MCAST_MEMBER; 498255932Salfred ret = 1; 499255932Salfred } 500255932Salfred return ret; 501255932Salfred} 502255932Salfred 503255932Salfredstatic int leave_group(struct mcast_group *group, int slave, u8 leave_state) 504255932Salfred{ 505255932Salfred int ret = 0; 506255932Salfred 507255932Salfred adjust_membership(group, leave_state, -1); 508255932Salfred group->func[slave].join_state &= ~leave_state; 509255932Salfred if (!group->func[slave].join_state) { 510255932Salfred group->func[slave].state = MCAST_NOT_MEMBER; 511255932Salfred ret = 1; 512255932Salfred } 513255932Salfred return ret; 514255932Salfred} 515255932Salfred 516255932Salfredstatic int check_leave(struct mcast_group *group, int slave, u8 leave_mask) 517255932Salfred{ 518255932Salfred if (group->func[slave].state != MCAST_MEMBER) 519255932Salfred return MAD_STATUS_REQ_INVALID; 520255932Salfred 521255932Salfred /* make sure we're not deleting unset bits */ 522255932Salfred if (~group->func[slave].join_state & leave_mask) 523255932Salfred return MAD_STATUS_REQ_INVALID; 524255932Salfred 525255932Salfred if (!leave_mask) 526255932Salfred return MAD_STATUS_REQ_INVALID; 527255932Salfred 528255932Salfred return 0; 529255932Salfred} 530255932Salfred 531255932Salfredstatic void mlx4_ib_mcg_timeout_handler(struct work_struct *work) 532255932Salfred{ 533255932Salfred struct delayed_work *delay = to_delayed_work(work); 534255932Salfred struct mcast_group *group; 535255932Salfred struct mcast_req *req = NULL; 536255932Salfred 537255932Salfred group = container_of(delay, typeof(*group), timeout_work); 538255932Salfred 539255932Salfred mutex_lock(&group->lock); 540255932Salfred if (group->state == MCAST_JOIN_SENT) { 541255932Salfred if (!list_empty(&group->pending_list)) { 542255932Salfred req = list_first_entry(&group->pending_list, struct mcast_req, group_list); 543255932Salfred list_del(&req->group_list); 544255932Salfred list_del(&req->func_list); 545255932Salfred --group->func[req->func].num_pend_reqs; 546255932Salfred mutex_unlock(&group->lock); 547255932Salfred kfree(req); 548255932Salfred if (memcmp(&group->rec.mgid, &mgid0, sizeof mgid0)) { 549255932Salfred if (release_group(group, 1)) 550255932Salfred return; 551255932Salfred } else { 552255932Salfred kfree(group); 553255932Salfred return; 554255932Salfred } 555255932Salfred mutex_lock(&group->lock); 556255932Salfred } else 557255932Salfred mcg_warn_group(group, "DRIVER BUG\n"); 558255932Salfred } else if (group->state == MCAST_LEAVE_SENT) { 559255932Salfred if (group->rec.scope_join_state & 7) 560255932Salfred group->rec.scope_join_state &= 0xf8; 561255932Salfred group->state = MCAST_IDLE; 562255932Salfred mutex_unlock(&group->lock); 563255932Salfred if (release_group(group, 1)) 564255932Salfred return; 565255932Salfred mutex_lock(&group->lock); 566255932Salfred } else 567255932Salfred mcg_warn_group(group, "invalid state %s\n", get_state_string(group->state)); 568255932Salfred group->state = MCAST_IDLE; 569255932Salfred atomic_inc(&group->refcount); 570255932Salfred queue_work(group->demux->mcg_wq, &group->work); 571255932Salfred safe_atomic_dec(&group->refcount); 572255932Salfred 573255932Salfred mutex_unlock(&group->lock); 574255932Salfred} 575255932Salfred 576255932Salfredstatic int handle_leave_req(struct mcast_group *group, u8 leave_mask, 577255932Salfred struct mcast_req *req) 578255932Salfred{ 579255932Salfred u16 status; 580255932Salfred 581255932Salfred if (req->clean) 582255932Salfred leave_mask = group->func[req->func].join_state; 583255932Salfred 584255932Salfred status = check_leave(group, req->func, leave_mask); 585255932Salfred if (!status) 586255932Salfred leave_group(group, req->func, leave_mask); 587255932Salfred 588255932Salfred if (!req->clean) 589255932Salfred send_reply_to_slave(req->func, group, &req->sa_mad, status); 590255932Salfred --group->func[req->func].num_pend_reqs; 591255932Salfred list_del(&req->group_list); 592255932Salfred list_del(&req->func_list); 593255932Salfred kfree(req); 594255932Salfred return 1; 595255932Salfred} 596255932Salfred 597255932Salfredstatic int handle_join_req(struct mcast_group *group, u8 join_mask, 598255932Salfred struct mcast_req *req) 599255932Salfred{ 600255932Salfred u8 group_join_state = group->rec.scope_join_state & 7; 601255932Salfred int ref = 0; 602255932Salfred u16 status; 603255932Salfred struct ib_sa_mcmember_data *sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data; 604255932Salfred 605255932Salfred if (join_mask == (group_join_state & join_mask)) { 606255932Salfred /* port's membership need not change */ 607255932Salfred status = cmp_rec(&group->rec, sa_data, req->sa_mad.sa_hdr.comp_mask); 608255932Salfred if (!status) 609255932Salfred join_group(group, req->func, join_mask); 610255932Salfred 611255932Salfred --group->func[req->func].num_pend_reqs; 612255932Salfred send_reply_to_slave(req->func, group, &req->sa_mad, status); 613255932Salfred list_del(&req->group_list); 614255932Salfred list_del(&req->func_list); 615255932Salfred kfree(req); 616255932Salfred ++ref; 617255932Salfred } else { 618255932Salfred /* port's membership needs to be updated */ 619255932Salfred group->prev_state = group->state; 620255932Salfred if (send_join_to_wire(group, &req->sa_mad)) { 621255932Salfred --group->func[req->func].num_pend_reqs; 622255932Salfred list_del(&req->group_list); 623255932Salfred list_del(&req->func_list); 624255932Salfred kfree(req); 625255932Salfred ref = 1; 626255932Salfred group->state = group->prev_state; 627255932Salfred } else 628255932Salfred group->state = MCAST_JOIN_SENT; 629255932Salfred } 630255932Salfred 631255932Salfred return ref; 632255932Salfred} 633255932Salfred 634255932Salfredstatic void mlx4_ib_mcg_work_handler(struct work_struct *work) 635255932Salfred{ 636255932Salfred struct mcast_group *group; 637255932Salfred struct mcast_req *req = NULL; 638255932Salfred struct ib_sa_mcmember_data *sa_data; 639255932Salfred u8 req_join_state; 640255932Salfred int rc = 1; /* release_count - this is for the scheduled work */ 641255932Salfred u16 status; 642255932Salfred u8 method; 643255932Salfred 644255932Salfred group = container_of(work, typeof(*group), work); 645255932Salfred 646255932Salfred mutex_lock(&group->lock); 647255932Salfred 648255932Salfred /* First, let's see if a response from SM is waiting regarding this group. 649255932Salfred * If so, we need to update the group's REC. If this is a bad response, we 650255932Salfred * may need to send a bad response to a VF waiting for it. If VF is waiting 651255932Salfred * and this is a good response, the VF will be answered later in this func. */ 652255932Salfred if (group->state == MCAST_RESP_READY) { 653255932Salfred /* cancels mlx4_ib_mcg_timeout_handler */ 654255932Salfred cancel_delayed_work(&group->timeout_work); 655255932Salfred status = be16_to_cpu(group->response_sa_mad.mad_hdr.status); 656255932Salfred method = group->response_sa_mad.mad_hdr.method; 657255932Salfred if (group->last_req_tid != group->response_sa_mad.mad_hdr.tid) { 658255932Salfred mcg_warn_group(group, "Got MAD response to existing MGID but wrong TID, dropping. Resp TID=%llx, group TID=%llx\n", 659255932Salfred (long long unsigned int)be64_to_cpu(group->response_sa_mad.mad_hdr.tid), 660255932Salfred (long long unsigned int)be64_to_cpu(group->last_req_tid)); 661255932Salfred group->state = group->prev_state; 662255932Salfred goto process_requests; 663255932Salfred } 664255932Salfred if (status) { 665255932Salfred if (!list_empty(&group->pending_list)) 666255932Salfred req = list_first_entry(&group->pending_list, 667255932Salfred struct mcast_req, group_list); 668269861Shselasky if (method == IB_MGMT_METHOD_GET_RESP) { 669255932Salfred if (req) { 670255932Salfred send_reply_to_slave(req->func, group, &req->sa_mad, status); 671255932Salfred --group->func[req->func].num_pend_reqs; 672255932Salfred list_del(&req->group_list); 673255932Salfred list_del(&req->func_list); 674255932Salfred kfree(req); 675255932Salfred ++rc; 676255932Salfred } else 677255932Salfred mcg_warn_group(group, "no request for failed join\n"); 678255932Salfred } else if (method == IB_SA_METHOD_DELETE_RESP && group->demux->flushing) 679255932Salfred ++rc; 680255932Salfred } else { 681255932Salfred u8 resp_join_state; 682255932Salfred u8 cur_join_state; 683255932Salfred 684255932Salfred resp_join_state = ((struct ib_sa_mcmember_data *) 685255932Salfred group->response_sa_mad.data)->scope_join_state & 7; 686255932Salfred cur_join_state = group->rec.scope_join_state & 7; 687255932Salfred 688255932Salfred if (method == IB_MGMT_METHOD_GET_RESP) { 689255932Salfred /* successfull join */ 690255932Salfred if (!cur_join_state && resp_join_state) 691255932Salfred --rc; 692255932Salfred } else if (!resp_join_state) 693255932Salfred ++rc; 694255932Salfred memcpy(&group->rec, group->response_sa_mad.data, sizeof group->rec); 695255932Salfred } 696255932Salfred group->state = MCAST_IDLE; 697255932Salfred } 698255932Salfred 699255932Salfredprocess_requests: 700255932Salfred /* We should now go over pending join/leave requests, as long as we are idle. */ 701255932Salfred while (!list_empty(&group->pending_list) && group->state == MCAST_IDLE) { 702255932Salfred req = list_first_entry(&group->pending_list, struct mcast_req, 703255932Salfred group_list); 704255932Salfred sa_data = (struct ib_sa_mcmember_data *)req->sa_mad.data; 705255932Salfred req_join_state = sa_data->scope_join_state & 0x7; 706255932Salfred 707255932Salfred /* For a leave request, we will immediately answer the VF, and 708255932Salfred * update our internal counters. The actual leave will be sent 709255932Salfred * to SM later, if at all needed. We dequeue the request now. */ 710255932Salfred if (req->sa_mad.mad_hdr.method == IB_SA_METHOD_DELETE) 711255932Salfred rc += handle_leave_req(group, req_join_state, req); 712255932Salfred else 713255932Salfred rc += handle_join_req(group, req_join_state, req); 714255932Salfred } 715255932Salfred 716255932Salfred /* Handle leaves */ 717255932Salfred if (group->state == MCAST_IDLE) { 718255932Salfred req_join_state = get_leave_state(group); 719255932Salfred if (req_join_state) { 720255932Salfred group->rec.scope_join_state &= ~req_join_state; 721255932Salfred group->prev_state = group->state; 722255932Salfred if (send_leave_to_wire(group, req_join_state)) { 723255932Salfred group->state = group->prev_state; 724255932Salfred ++rc; 725255932Salfred } else 726255932Salfred group->state = MCAST_LEAVE_SENT; 727255932Salfred } 728255932Salfred } 729255932Salfred 730255932Salfred if (!list_empty(&group->pending_list) && group->state == MCAST_IDLE) 731255932Salfred goto process_requests; 732255932Salfred mutex_unlock(&group->lock); 733255932Salfred 734255932Salfred while (rc--) 735255932Salfred release_group(group, 0); 736255932Salfred} 737255932Salfred 738255932Salfredstatic struct mcast_group *search_relocate_mgid0_group(struct mlx4_ib_demux_ctx *ctx, 739255932Salfred __be64 tid, 740255932Salfred union ib_gid *new_mgid) 741255932Salfred{ 742255932Salfred struct mcast_group *group = NULL, *cur_group; 743255932Salfred struct mcast_req *req; 744255932Salfred struct list_head *pos; 745255932Salfred struct list_head *n; 746255932Salfred 747255932Salfred mutex_lock(&ctx->mcg_table_lock); 748255932Salfred list_for_each_safe(pos, n, &ctx->mcg_mgid0_list) { 749255932Salfred group = list_entry(pos, struct mcast_group, mgid0_list); 750255932Salfred mutex_lock(&group->lock); 751255932Salfred if (group->last_req_tid == tid) { 752255932Salfred if (memcmp(new_mgid, &mgid0, sizeof mgid0)) { 753255932Salfred group->rec.mgid = *new_mgid; 754255932Salfred sprintf(group->name, "%016llx%016llx", 755255932Salfred (long long unsigned int)be64_to_cpu(group->rec.mgid.global.subnet_prefix), 756255932Salfred (long long unsigned int)be64_to_cpu(group->rec.mgid.global.interface_id)); 757255932Salfred list_del_init(&group->mgid0_list); 758255932Salfred cur_group = mcast_insert(ctx, group); 759255932Salfred if (cur_group) { 760255932Salfred /* A race between our code and SM. Silently cleaning the new one */ 761255932Salfred req = list_first_entry(&group->pending_list, 762255932Salfred struct mcast_req, group_list); 763255932Salfred --group->func[req->func].num_pend_reqs; 764255932Salfred list_del(&req->group_list); 765255932Salfred list_del(&req->func_list); 766255932Salfred kfree(req); 767255932Salfred mutex_unlock(&group->lock); 768255932Salfred mutex_unlock(&ctx->mcg_table_lock); 769255932Salfred release_group(group, 0); 770255932Salfred return NULL; 771255932Salfred } 772255932Salfred 773255932Salfred atomic_inc(&group->refcount); 774255932Salfred add_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr); 775255932Salfred mutex_unlock(&group->lock); 776255932Salfred mutex_unlock(&ctx->mcg_table_lock); 777255932Salfred return group; 778255932Salfred } else { 779255932Salfred struct mcast_req *tmp1, *tmp2; 780255932Salfred 781255932Salfred list_del(&group->mgid0_list); 782255932Salfred if (!list_empty(&group->pending_list) && group->state != MCAST_IDLE) 783255932Salfred cancel_delayed_work_sync(&group->timeout_work); 784255932Salfred 785255932Salfred list_for_each_entry_safe(tmp1, tmp2, &group->pending_list, group_list) { 786255932Salfred list_del(&tmp1->group_list); 787255932Salfred kfree(tmp1); 788255932Salfred } 789255932Salfred mutex_unlock(&group->lock); 790255932Salfred mutex_unlock(&ctx->mcg_table_lock); 791255932Salfred kfree(group); 792255932Salfred return NULL; 793255932Salfred } 794255932Salfred } 795255932Salfred mutex_unlock(&group->lock); 796255932Salfred } 797255932Salfred mutex_unlock(&ctx->mcg_table_lock); 798255932Salfred 799255932Salfred return NULL; 800255932Salfred} 801255932Salfred 802255932Salfredstatic ssize_t sysfs_show_group(struct device *dev, 803255932Salfred struct device_attribute *attr, char *buf); 804255932Salfred 805255932Salfredstatic struct mcast_group *acquire_group(struct mlx4_ib_demux_ctx *ctx, 806255932Salfred union ib_gid *mgid, int create, 807255932Salfred gfp_t gfp_mask) 808255932Salfred{ 809255932Salfred struct mcast_group *group, *cur_group; 810255932Salfred int is_mgid0; 811255932Salfred int i; 812255932Salfred 813255932Salfred is_mgid0 = !memcmp(&mgid0, mgid, sizeof mgid0); 814255932Salfred if (!is_mgid0) { 815255932Salfred group = mcast_find(ctx, mgid); 816255932Salfred if (group) 817255932Salfred goto found; 818255932Salfred } 819255932Salfred 820255932Salfred if (!create) 821255932Salfred return ERR_PTR(-ENOENT); 822255932Salfred 823255932Salfred group = kzalloc(sizeof *group, gfp_mask); 824255932Salfred if (!group) 825255932Salfred return ERR_PTR(-ENOMEM); 826255932Salfred 827255932Salfred group->demux = ctx; 828255932Salfred group->rec.mgid = *mgid; 829255932Salfred INIT_LIST_HEAD(&group->pending_list); 830255932Salfred INIT_LIST_HEAD(&group->mgid0_list); 831255932Salfred for (i = 0; i < MAX_VFS; ++i) 832255932Salfred INIT_LIST_HEAD(&group->func[i].pending); 833255932Salfred INIT_WORK(&group->work, mlx4_ib_mcg_work_handler); 834255932Salfred INIT_DELAYED_WORK(&group->timeout_work, mlx4_ib_mcg_timeout_handler); 835255932Salfred mutex_init(&group->lock); 836255932Salfred sprintf(group->name, "%016llx%016llx", 837255932Salfred (long long unsigned int)be64_to_cpu(group->rec.mgid.global.subnet_prefix), 838255932Salfred (long long unsigned int)be64_to_cpu(group->rec.mgid.global.interface_id)); 839255932Salfred sysfs_attr_init(&group->dentry.attr); 840255932Salfred group->dentry.show = sysfs_show_group; 841255932Salfred group->dentry.store = NULL; 842255932Salfred group->dentry.attr.name = group->name; 843255932Salfred group->dentry.attr.mode = 0400; 844255932Salfred group->state = MCAST_IDLE; 845255932Salfred 846255932Salfred if (is_mgid0) { 847255932Salfred list_add(&group->mgid0_list, &ctx->mcg_mgid0_list); 848255932Salfred goto found; 849255932Salfred } 850255932Salfred 851255932Salfred cur_group = mcast_insert(ctx, group); 852255932Salfred if (cur_group) { 853255932Salfred mcg_warn("group just showed up %s - confused\n", cur_group->name); 854255932Salfred kfree(group); 855255932Salfred return ERR_PTR(-EINVAL); 856255932Salfred } 857255932Salfred 858255932Salfred add_sysfs_port_mcg_attr(ctx->dev, ctx->port, &group->dentry.attr); 859255932Salfred 860255932Salfredfound: 861255932Salfred atomic_inc(&group->refcount); 862255932Salfred return group; 863255932Salfred} 864255932Salfred 865255932Salfredstatic void queue_req(struct mcast_req *req) 866255932Salfred{ 867255932Salfred struct mcast_group *group = req->group; 868255932Salfred 869255932Salfred atomic_inc(&group->refcount); /* for the request */ 870255932Salfred atomic_inc(&group->refcount); /* for scheduling the work */ 871255932Salfred list_add_tail(&req->group_list, &group->pending_list); 872255932Salfred list_add_tail(&req->func_list, &group->func[req->func].pending); 873255932Salfred /* calls mlx4_ib_mcg_work_handler */ 874255932Salfred queue_work(group->demux->mcg_wq, &group->work); 875255932Salfred safe_atomic_dec(&group->refcount); 876255932Salfred} 877255932Salfred 878255932Salfredint mlx4_ib_mcg_demux_handler(struct ib_device *ibdev, int port, int slave, 879255932Salfred struct ib_sa_mad *mad) 880255932Salfred{ 881255932Salfred struct mlx4_ib_dev *dev = to_mdev(ibdev); 882255932Salfred struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)mad->data; 883255932Salfred struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1]; 884255932Salfred struct mcast_group *group; 885255932Salfred 886255932Salfred switch (mad->mad_hdr.method) { 887255932Salfred case IB_MGMT_METHOD_GET_RESP: 888255932Salfred case IB_SA_METHOD_DELETE_RESP: 889255932Salfred mutex_lock(&ctx->mcg_table_lock); 890255932Salfred group = acquire_group(ctx, &rec->mgid, 0, GFP_KERNEL); 891255932Salfred mutex_unlock(&ctx->mcg_table_lock); 892255932Salfred if (IS_ERR(group)) { 893255932Salfred if (mad->mad_hdr.method == IB_MGMT_METHOD_GET_RESP) { 894255932Salfred __be64 tid = mad->mad_hdr.tid; 895255932Salfred *(u8 *)(&tid) = (u8)slave; /* in group we kept the modified TID */ 896255932Salfred group = search_relocate_mgid0_group(ctx, tid, &rec->mgid); 897255932Salfred } else 898255932Salfred group = NULL; 899255932Salfred } 900255932Salfred 901255932Salfred if (!group) 902255932Salfred return 1; 903255932Salfred 904255932Salfred mutex_lock(&group->lock); 905255932Salfred group->response_sa_mad = *mad; 906255932Salfred group->prev_state = group->state; 907255932Salfred group->state = MCAST_RESP_READY; 908255932Salfred /* calls mlx4_ib_mcg_work_handler */ 909255932Salfred atomic_inc(&group->refcount); 910255932Salfred queue_work(ctx->mcg_wq, &group->work); 911255932Salfred safe_atomic_dec(&group->refcount); 912255932Salfred mutex_unlock(&group->lock); 913255932Salfred release_group(group, 0); 914255932Salfred return 1; /* consumed */ 915255932Salfred case IB_MGMT_METHOD_SET: 916255932Salfred case IB_SA_METHOD_GET_TABLE: 917255932Salfred case IB_SA_METHOD_GET_TABLE_RESP: 918255932Salfred case IB_SA_METHOD_DELETE: 919255932Salfred return 0; /* not consumed, pass-through to guest over tunnel */ 920255932Salfred default: 921255932Salfred mcg_warn("In demux, port %d: unexpected MCMember method: 0x%x, dropping\n", 922255932Salfred port, mad->mad_hdr.method); 923255932Salfred return 1; /* consumed */ 924255932Salfred } 925255932Salfred} 926255932Salfred 927255932Salfredint mlx4_ib_mcg_multiplex_handler(struct ib_device *ibdev, int port, 928255932Salfred int slave, struct ib_sa_mad *sa_mad) 929255932Salfred{ 930255932Salfred struct mlx4_ib_dev *dev = to_mdev(ibdev); 931255932Salfred struct ib_sa_mcmember_data *rec = (struct ib_sa_mcmember_data *)sa_mad->data; 932255932Salfred struct mlx4_ib_demux_ctx *ctx = &dev->sriov.demux[port - 1]; 933255932Salfred struct mcast_group *group; 934255932Salfred struct mcast_req *req; 935255932Salfred int may_create = 0; 936255932Salfred 937255932Salfred if (ctx->flushing) 938255932Salfred return -EAGAIN; 939255932Salfred 940255932Salfred switch (sa_mad->mad_hdr.method) { 941255932Salfred case IB_MGMT_METHOD_SET: 942255932Salfred may_create = 1; 943255932Salfred case IB_SA_METHOD_DELETE: 944255932Salfred req = kzalloc(sizeof *req, GFP_KERNEL); 945255932Salfred if (!req) 946255932Salfred return -ENOMEM; 947255932Salfred 948255932Salfred req->func = slave; 949255932Salfred req->sa_mad = *sa_mad; 950255932Salfred 951255932Salfred mutex_lock(&ctx->mcg_table_lock); 952255932Salfred group = acquire_group(ctx, &rec->mgid, may_create, GFP_KERNEL); 953255932Salfred mutex_unlock(&ctx->mcg_table_lock); 954255932Salfred if (IS_ERR(group)) { 955255932Salfred kfree(req); 956255932Salfred return PTR_ERR(group); 957255932Salfred } 958255932Salfred mutex_lock(&group->lock); 959255932Salfred if (group->func[slave].num_pend_reqs > MAX_PEND_REQS_PER_FUNC) { 960255932Salfred mutex_unlock(&group->lock); 961255932Salfred mcg_warn_group(group, "Port %d, Func %d has too many pending requests (%d), dropping\n", 962255932Salfred port, slave, MAX_PEND_REQS_PER_FUNC); 963255932Salfred release_group(group, 0); 964255932Salfred kfree(req); 965255932Salfred return -ENOMEM; 966255932Salfred } 967255932Salfred ++group->func[slave].num_pend_reqs; 968255932Salfred req->group = group; 969255932Salfred queue_req(req); 970255932Salfred mutex_unlock(&group->lock); 971255932Salfred release_group(group, 0); 972255932Salfred return 1; /* consumed */ 973255932Salfred case IB_SA_METHOD_GET_TABLE: 974255932Salfred case IB_MGMT_METHOD_GET_RESP: 975255932Salfred case IB_SA_METHOD_GET_TABLE_RESP: 976255932Salfred case IB_SA_METHOD_DELETE_RESP: 977255932Salfred return 0; /* not consumed, pass-through */ 978255932Salfred default: 979255932Salfred mcg_warn("In multiplex, port %d, func %d: unexpected MCMember method: 0x%x, dropping\n", 980255932Salfred port, slave, sa_mad->mad_hdr.method); 981255932Salfred return 1; /* consumed */ 982255932Salfred } 983255932Salfred} 984255932Salfred 985255932Salfredstatic ssize_t sysfs_show_group(struct device *dev, 986255932Salfred struct device_attribute *attr, char *buf) 987255932Salfred{ 988255932Salfred struct mcast_group *group = 989255932Salfred container_of(attr, struct mcast_group, dentry); 990255932Salfred struct mcast_req *req = NULL; 991255932Salfred char pending_str[40]; 992255932Salfred char state_str[40]; 993255932Salfred ssize_t len = 0; 994255932Salfred int f; 995255932Salfred 996255932Salfred if (group->state == MCAST_IDLE) 997255932Salfred sprintf(state_str, "%s", get_state_string(group->state)); 998255932Salfred else 999255932Salfred sprintf(state_str, "%s(TID=0x%llx)", 1000255932Salfred get_state_string(group->state), 1001255932Salfred (long long unsigned int)be64_to_cpu(group->last_req_tid)); 1002255932Salfred if (list_empty(&group->pending_list)) { 1003255932Salfred sprintf(pending_str, "No"); 1004255932Salfred } else { 1005255932Salfred req = list_first_entry(&group->pending_list, struct mcast_req, group_list); 1006255932Salfred sprintf(pending_str, "Yes(TID=0x%llx)", 1007255932Salfred (long long unsigned int)be64_to_cpu(req->sa_mad.mad_hdr.tid)); 1008255932Salfred } 1009255932Salfred len += sprintf(buf + len, "%1d [%02d,%02d,%02d] %4d %4s %5s ", 1010255932Salfred group->rec.scope_join_state & 0xf, 1011255932Salfred group->members[2], group->members[1], group->members[0], 1012255932Salfred atomic_read(&group->refcount), 1013255932Salfred pending_str, 1014255932Salfred state_str); 1015255932Salfred for (f = 0; f < MAX_VFS; ++f) 1016255932Salfred if (group->func[f].state == MCAST_MEMBER) 1017255932Salfred len += sprintf(buf + len, "%d[%1x] ", 1018255932Salfred f, group->func[f].join_state); 1019255932Salfred 1020255932Salfred len += sprintf(buf + len, "\t\t(%4hx %4x %2x %2x %2x %2x %2x " 1021255932Salfred "%4x %4x %2x %2x)\n", 1022255932Salfred be16_to_cpu(group->rec.pkey), 1023255932Salfred be32_to_cpu(group->rec.qkey), 1024255932Salfred (group->rec.mtusel_mtu & 0xc0) >> 6, 1025255932Salfred group->rec.mtusel_mtu & 0x3f, 1026255932Salfred group->rec.tclass, 1027255932Salfred (group->rec.ratesel_rate & 0xc0) >> 6, 1028255932Salfred group->rec.ratesel_rate & 0x3f, 1029255932Salfred (be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0xf0000000) >> 28, 1030255932Salfred (be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0x0fffff00) >> 8, 1031255932Salfred be32_to_cpu(group->rec.sl_flowlabel_hoplimit) & 0x000000ff, 1032255932Salfred group->rec.proxy_join); 1033255932Salfred 1034255932Salfred return len; 1035255932Salfred} 1036255932Salfred 1037255932Salfredint mlx4_ib_mcg_port_init(struct mlx4_ib_demux_ctx *ctx) 1038255932Salfred{ 1039255932Salfred char name[20]; 1040255932Salfred 1041255932Salfred atomic_set(&ctx->tid, 0); 1042255932Salfred sprintf(name, "mlx4_ib_mcg%d", ctx->port); 1043255932Salfred ctx->mcg_wq = create_singlethread_workqueue(name); 1044255932Salfred if (!ctx->mcg_wq) 1045255932Salfred return -ENOMEM; 1046255932Salfred 1047255932Salfred mutex_init(&ctx->mcg_table_lock); 1048255932Salfred ctx->mcg_table = RB_ROOT; 1049255932Salfred INIT_LIST_HEAD(&ctx->mcg_mgid0_list); 1050255932Salfred ctx->flushing = 0; 1051255932Salfred 1052255932Salfred return 0; 1053255932Salfred} 1054255932Salfred 1055255932Salfredstatic void force_clean_group(struct mcast_group *group) 1056255932Salfred{ 1057255932Salfred struct mcast_req *req, *tmp 1058255932Salfred ; 1059255932Salfred list_for_each_entry_safe(req, tmp, &group->pending_list, group_list) { 1060255932Salfred list_del(&req->group_list); 1061255932Salfred kfree(req); 1062255932Salfred } 1063255932Salfred del_sysfs_port_mcg_attr(group->demux->dev, group->demux->port, &group->dentry.attr); 1064255932Salfred rb_erase(&group->node, &group->demux->mcg_table); 1065255932Salfred kfree(group); 1066255932Salfred} 1067255932Salfred 1068255932Salfredstatic void _mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq) 1069255932Salfred{ 1070255932Salfred int i; 1071255932Salfred struct rb_node *p; 1072255932Salfred struct mcast_group *group; 1073255932Salfred unsigned long end; 1074255932Salfred int count; 1075255932Salfred 1076255932Salfred for (i = 0; i < MAX_VFS; ++i) 1077255932Salfred clean_vf_mcast(ctx, i); 1078255932Salfred 1079255932Salfred end = jiffies + msecs_to_jiffies(MAD_TIMEOUT_MS + 3000); 1080255932Salfred do { 1081255932Salfred count = 0; 1082255932Salfred mutex_lock(&ctx->mcg_table_lock); 1083255932Salfred for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p)) 1084255932Salfred ++count; 1085255932Salfred mutex_unlock(&ctx->mcg_table_lock); 1086255932Salfred if (!count) 1087255932Salfred break; 1088255932Salfred 1089255932Salfred msleep(1); 1090255932Salfred } while (time_after(end, jiffies)); 1091255932Salfred 1092255932Salfred flush_workqueue(ctx->mcg_wq); 1093255932Salfred if (destroy_wq) 1094255932Salfred destroy_workqueue(ctx->mcg_wq); 1095255932Salfred 1096255932Salfred mutex_lock(&ctx->mcg_table_lock); 1097255932Salfred while ((p = rb_first(&ctx->mcg_table)) != NULL) { 1098255932Salfred group = rb_entry(p, struct mcast_group, node); 1099255932Salfred if (atomic_read(&group->refcount)) 1100255932Salfred mcg_warn_group(group, "group refcount %d!!! (pointer %p)\n", atomic_read(&group->refcount), group); 1101255932Salfred 1102255932Salfred force_clean_group(group); 1103255932Salfred } 1104255932Salfred mutex_unlock(&ctx->mcg_table_lock); 1105255932Salfred} 1106255932Salfred 1107255932Salfredstruct clean_work { 1108255932Salfred struct work_struct work; 1109255932Salfred struct mlx4_ib_demux_ctx *ctx; 1110255932Salfred int destroy_wq; 1111255932Salfred}; 1112255932Salfred 1113255932Salfredstatic void mcg_clean_task(struct work_struct *work) 1114255932Salfred{ 1115255932Salfred struct clean_work *cw = container_of(work, struct clean_work, work); 1116255932Salfred 1117255932Salfred _mlx4_ib_mcg_port_cleanup(cw->ctx, cw->destroy_wq); 1118255932Salfred cw->ctx->flushing = 0; 1119255932Salfred kfree(cw); 1120255932Salfred} 1121255932Salfred 1122255932Salfredvoid mlx4_ib_mcg_port_cleanup(struct mlx4_ib_demux_ctx *ctx, int destroy_wq) 1123255932Salfred{ 1124255932Salfred struct clean_work *work; 1125255932Salfred 1126255932Salfred if (ctx->flushing) 1127255932Salfred return; 1128255932Salfred 1129255932Salfred ctx->flushing = 1; 1130255932Salfred 1131255932Salfred if (destroy_wq) { 1132255932Salfred _mlx4_ib_mcg_port_cleanup(ctx, destroy_wq); 1133255932Salfred ctx->flushing = 0; 1134255932Salfred return; 1135255932Salfred } 1136255932Salfred 1137255932Salfred work = kmalloc(sizeof *work, GFP_KERNEL); 1138255932Salfred if (!work) { 1139255932Salfred ctx->flushing = 0; 1140255932Salfred mcg_warn("failed allocating work for cleanup\n"); 1141255932Salfred return; 1142255932Salfred } 1143255932Salfred 1144255932Salfred work->ctx = ctx; 1145255932Salfred work->destroy_wq = destroy_wq; 1146255932Salfred INIT_WORK(&work->work, mcg_clean_task); 1147255932Salfred queue_work(clean_wq, &work->work); 1148255932Salfred} 1149255932Salfred 1150255932Salfredstatic void build_leave_mad(struct mcast_req *req) 1151255932Salfred{ 1152255932Salfred struct ib_sa_mad *mad = &req->sa_mad; 1153255932Salfred 1154255932Salfred mad->mad_hdr.method = IB_SA_METHOD_DELETE; 1155255932Salfred} 1156255932Salfred 1157255932Salfred 1158255932Salfredstatic void clear_pending_reqs(struct mcast_group *group, int vf) 1159255932Salfred{ 1160255932Salfred struct mcast_req *req, *tmp, *group_first = NULL; 1161255932Salfred int clear; 1162255932Salfred int pend = 0; 1163255932Salfred 1164255932Salfred if (!list_empty(&group->pending_list)) 1165255932Salfred group_first = list_first_entry(&group->pending_list, struct mcast_req, group_list); 1166255932Salfred 1167255932Salfred list_for_each_entry_safe(req, tmp, &group->func[vf].pending, func_list) { 1168255932Salfred clear = 1; 1169255932Salfred if (group_first == req && 1170255932Salfred (group->state == MCAST_JOIN_SENT || 1171255932Salfred group->state == MCAST_LEAVE_SENT)) { 1172255932Salfred clear = cancel_delayed_work(&group->timeout_work); 1173255932Salfred pend = !clear; 1174255932Salfred group->state = MCAST_IDLE; 1175255932Salfred } 1176255932Salfred if (clear) { 1177255932Salfred --group->func[vf].num_pend_reqs; 1178255932Salfred list_del(&req->group_list); 1179255932Salfred list_del(&req->func_list); 1180255932Salfred kfree(req); 1181255932Salfred atomic_dec(&group->refcount); 1182255932Salfred } 1183255932Salfred } 1184255932Salfred 1185255932Salfred if (!pend && (!list_empty(&group->func[vf].pending) || group->func[vf].num_pend_reqs)) { 1186255932Salfred mcg_warn_group(group, "DRIVER BUG: list_empty %d, num_pend_reqs %d\n", 1187255932Salfred list_empty(&group->func[vf].pending), group->func[vf].num_pend_reqs); 1188255932Salfred } 1189255932Salfred} 1190255932Salfred 1191255932Salfredstatic int push_deleteing_req(struct mcast_group *group, int slave) 1192255932Salfred{ 1193255932Salfred struct mcast_req *req; 1194255932Salfred struct mcast_req *pend_req; 1195255932Salfred 1196255932Salfred if (!group->func[slave].join_state) 1197255932Salfred return 0; 1198255932Salfred 1199255932Salfred req = kzalloc(sizeof *req, GFP_KERNEL); 1200255932Salfred if (!req) { 1201255932Salfred mcg_warn_group(group, "failed allocation - may leave stall groups\n"); 1202255932Salfred return -ENOMEM; 1203255932Salfred } 1204255932Salfred 1205255932Salfred if (!list_empty(&group->func[slave].pending)) { 1206255932Salfred pend_req = list_entry(group->func[slave].pending.prev, struct mcast_req, group_list); 1207255932Salfred if (pend_req->clean) { 1208255932Salfred kfree(req); 1209255932Salfred return 0; 1210255932Salfred } 1211255932Salfred } 1212255932Salfred 1213255932Salfred req->clean = 1; 1214255932Salfred req->func = slave; 1215255932Salfred req->group = group; 1216255932Salfred ++group->func[slave].num_pend_reqs; 1217255932Salfred build_leave_mad(req); 1218255932Salfred queue_req(req); 1219255932Salfred return 0; 1220255932Salfred} 1221255932Salfred 1222255932Salfredvoid clean_vf_mcast(struct mlx4_ib_demux_ctx *ctx, int slave) 1223255932Salfred{ 1224255932Salfred struct mcast_group *group; 1225255932Salfred struct rb_node *p; 1226255932Salfred 1227255932Salfred mutex_lock(&ctx->mcg_table_lock); 1228255932Salfred for (p = rb_first(&ctx->mcg_table); p; p = rb_next(p)) { 1229255932Salfred group = rb_entry(p, struct mcast_group, node); 1230255932Salfred mutex_lock(&group->lock); 1231255932Salfred if (atomic_read(&group->refcount)) { 1232255932Salfred /* clear pending requests of this VF */ 1233255932Salfred clear_pending_reqs(group, slave); 1234255932Salfred push_deleteing_req(group, slave); 1235255932Salfred } 1236255932Salfred mutex_unlock(&group->lock); 1237255932Salfred } 1238255932Salfred mutex_unlock(&ctx->mcg_table_lock); 1239255932Salfred} 1240255932Salfred 1241255932Salfred 1242255932Salfredint mlx4_ib_mcg_init(void) 1243255932Salfred{ 1244255932Salfred clean_wq = create_singlethread_workqueue("mlx4_ib_mcg"); 1245255932Salfred if (!clean_wq) 1246255932Salfred return -ENOMEM; 1247255932Salfred 1248255932Salfred return 0; 1249255932Salfred} 1250255932Salfred 1251255932Salfredvoid mlx4_ib_mcg_destroy(void) 1252255932Salfred{ 1253255932Salfred destroy_workqueue(clean_wq); 1254255932Salfred} 1255