ib_mad.c revision 331769
1/* 2 * Copyright (c) 2004-2007 Voltaire, Inc. All rights reserved. 3 * Copyright (c) 2005 Intel Corporation. All rights reserved. 4 * Copyright (c) 2005 Mellanox Technologies Ltd. All rights reserved. 5 * Copyright (c) 2009 HNR Consulting. All rights reserved. 6 * Copyright (c) 2014 Intel Corporation. All rights reserved. 7 * 8 * This software is available to you under a choice of one of two 9 * licenses. You may choose to be licensed under the terms of the GNU 10 * General Public License (GPL) Version 2, available from the file 11 * COPYING in the main directory of this source tree, or the 12 * OpenIB.org BSD license below: 13 * 14 * Redistribution and use in source and binary forms, with or 15 * without modification, are permitted provided that the following 16 * conditions are met: 17 * 18 * - Redistributions of source code must retain the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer. 21 * 22 * - Redistributions in binary form must reproduce the above 23 * copyright notice, this list of conditions and the following 24 * disclaimer in the documentation and/or other materials 25 * provided with the distribution. 26 * 27 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 28 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 29 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 30 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 31 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 32 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 33 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 34 * SOFTWARE. 35 * 36 */ 37 38#define LINUXKPI_PARAM_PREFIX ibcore_ 39#define KBUILD_MODNAME "ibcore" 40 41#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 42 43#include <linux/dma-mapping.h> 44#include <linux/slab.h> 45#include <linux/module.h> 46#include <rdma/ib_cache.h> 47 48#include "mad_priv.h" 49#include "mad_rmpp.h" 50#include "smi.h" 51#include "opa_smi.h" 52#include "agent.h" 53#include "core_priv.h" 54 55static int mad_sendq_size = IB_MAD_QP_SEND_SIZE; 56static int mad_recvq_size = IB_MAD_QP_RECV_SIZE; 57 58module_param_named(send_queue_size, mad_sendq_size, int, 0444); 59MODULE_PARM_DESC(send_queue_size, "Size of send queue in number of work requests"); 60module_param_named(recv_queue_size, mad_recvq_size, int, 0444); 61MODULE_PARM_DESC(recv_queue_size, "Size of receive queue in number of work requests"); 62 63static struct list_head ib_mad_port_list; 64static u32 ib_mad_client_id = 0; 65 66/* Port list lock */ 67static DEFINE_SPINLOCK(ib_mad_port_list_lock); 68 69/* Forward declarations */ 70static int method_in_use(struct ib_mad_mgmt_method_table **method, 71 struct ib_mad_reg_req *mad_reg_req); 72static void remove_mad_reg_req(struct ib_mad_agent_private *priv); 73static struct ib_mad_agent_private *find_mad_agent( 74 struct ib_mad_port_private *port_priv, 75 const struct ib_mad_hdr *mad); 76static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info, 77 struct ib_mad_private *mad); 78static void cancel_mads(struct ib_mad_agent_private *mad_agent_priv); 79static void timeout_sends(struct work_struct *work); 80static void local_completions(struct work_struct *work); 81static int add_nonoui_reg_req(struct ib_mad_reg_req *mad_reg_req, 82 struct ib_mad_agent_private *agent_priv, 83 u8 mgmt_class); 84static int add_oui_reg_req(struct ib_mad_reg_req *mad_reg_req, 85 struct ib_mad_agent_private *agent_priv); 86static bool ib_mad_send_error(struct ib_mad_port_private *port_priv, 87 struct ib_wc *wc); 88static void ib_mad_send_done(struct ib_cq *cq, struct ib_wc *wc); 89 90/* 91 * Returns a ib_mad_port_private structure or NULL for a device/port 92 * Assumes ib_mad_port_list_lock is being held 93 */ 94static inline struct ib_mad_port_private * 95__ib_get_mad_port(struct ib_device *device, int port_num) 96{ 97 struct ib_mad_port_private *entry; 98 99 list_for_each_entry(entry, &ib_mad_port_list, port_list) { 100 if (entry->device == device && entry->port_num == port_num) 101 return entry; 102 } 103 return NULL; 104} 105 106/* 107 * Wrapper function to return a ib_mad_port_private structure or NULL 108 * for a device/port 109 */ 110static inline struct ib_mad_port_private * 111ib_get_mad_port(struct ib_device *device, int port_num) 112{ 113 struct ib_mad_port_private *entry; 114 unsigned long flags; 115 116 spin_lock_irqsave(&ib_mad_port_list_lock, flags); 117 entry = __ib_get_mad_port(device, port_num); 118 spin_unlock_irqrestore(&ib_mad_port_list_lock, flags); 119 120 return entry; 121} 122 123static inline u8 convert_mgmt_class(u8 mgmt_class) 124{ 125 /* Alias IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE to 0 */ 126 return mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE ? 127 0 : mgmt_class; 128} 129 130static int get_spl_qp_index(enum ib_qp_type qp_type) 131{ 132 switch (qp_type) 133 { 134 case IB_QPT_SMI: 135 return 0; 136 case IB_QPT_GSI: 137 return 1; 138 default: 139 return -1; 140 } 141} 142 143static int vendor_class_index(u8 mgmt_class) 144{ 145 return mgmt_class - IB_MGMT_CLASS_VENDOR_RANGE2_START; 146} 147 148static int is_vendor_class(u8 mgmt_class) 149{ 150 if ((mgmt_class < IB_MGMT_CLASS_VENDOR_RANGE2_START) || 151 (mgmt_class > IB_MGMT_CLASS_VENDOR_RANGE2_END)) 152 return 0; 153 return 1; 154} 155 156static int is_vendor_oui(char *oui) 157{ 158 if (oui[0] || oui[1] || oui[2]) 159 return 1; 160 return 0; 161} 162 163static int is_vendor_method_in_use( 164 struct ib_mad_mgmt_vendor_class *vendor_class, 165 struct ib_mad_reg_req *mad_reg_req) 166{ 167 struct ib_mad_mgmt_method_table *method; 168 int i; 169 170 for (i = 0; i < MAX_MGMT_OUI; i++) { 171 if (!memcmp(vendor_class->oui[i], mad_reg_req->oui, 3)) { 172 method = vendor_class->method_table[i]; 173 if (method) { 174 if (method_in_use(&method, mad_reg_req)) 175 return 1; 176 else 177 break; 178 } 179 } 180 } 181 return 0; 182} 183 184int ib_response_mad(const struct ib_mad_hdr *hdr) 185{ 186 return ((hdr->method & IB_MGMT_METHOD_RESP) || 187 (hdr->method == IB_MGMT_METHOD_TRAP_REPRESS) || 188 ((hdr->mgmt_class == IB_MGMT_CLASS_BM) && 189 (hdr->attr_mod & IB_BM_ATTR_MOD_RESP))); 190} 191EXPORT_SYMBOL(ib_response_mad); 192 193/* 194 * ib_register_mad_agent - Register to send/receive MADs 195 */ 196struct ib_mad_agent *ib_register_mad_agent(struct ib_device *device, 197 u8 port_num, 198 enum ib_qp_type qp_type, 199 struct ib_mad_reg_req *mad_reg_req, 200 u8 rmpp_version, 201 ib_mad_send_handler send_handler, 202 ib_mad_recv_handler recv_handler, 203 void *context, 204 u32 registration_flags) 205{ 206 struct ib_mad_port_private *port_priv; 207 struct ib_mad_agent *ret = ERR_PTR(-EINVAL); 208 struct ib_mad_agent_private *mad_agent_priv; 209 struct ib_mad_reg_req *reg_req = NULL; 210 struct ib_mad_mgmt_class_table *class; 211 struct ib_mad_mgmt_vendor_class_table *vendor; 212 struct ib_mad_mgmt_vendor_class *vendor_class; 213 struct ib_mad_mgmt_method_table *method; 214 int ret2, qpn; 215 unsigned long flags; 216 u8 mgmt_class, vclass; 217 218 /* Validate parameters */ 219 qpn = get_spl_qp_index(qp_type); 220 if (qpn == -1) { 221 dev_notice(&device->dev, 222 "ib_register_mad_agent: invalid QP Type %d\n", 223 qp_type); 224 goto error1; 225 } 226 227 if (rmpp_version && rmpp_version != IB_MGMT_RMPP_VERSION) { 228 dev_notice(&device->dev, 229 "ib_register_mad_agent: invalid RMPP Version %u\n", 230 rmpp_version); 231 goto error1; 232 } 233 234 /* Validate MAD registration request if supplied */ 235 if (mad_reg_req) { 236 if (mad_reg_req->mgmt_class_version >= MAX_MGMT_VERSION) { 237 dev_notice(&device->dev, 238 "ib_register_mad_agent: invalid Class Version %u\n", 239 mad_reg_req->mgmt_class_version); 240 goto error1; 241 } 242 if (!recv_handler) { 243 dev_notice(&device->dev, 244 "ib_register_mad_agent: no recv_handler\n"); 245 goto error1; 246 } 247 if (mad_reg_req->mgmt_class >= MAX_MGMT_CLASS) { 248 /* 249 * IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE is the only 250 * one in this range currently allowed 251 */ 252 if (mad_reg_req->mgmt_class != 253 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) { 254 dev_notice(&device->dev, 255 "ib_register_mad_agent: Invalid Mgmt Class 0x%x\n", 256 mad_reg_req->mgmt_class); 257 goto error1; 258 } 259 } else if (mad_reg_req->mgmt_class == 0) { 260 /* 261 * Class 0 is reserved in IBA and is used for 262 * aliasing of IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE 263 */ 264 dev_notice(&device->dev, 265 "ib_register_mad_agent: Invalid Mgmt Class 0\n"); 266 goto error1; 267 } else if (is_vendor_class(mad_reg_req->mgmt_class)) { 268 /* 269 * If class is in "new" vendor range, 270 * ensure supplied OUI is not zero 271 */ 272 if (!is_vendor_oui(mad_reg_req->oui)) { 273 dev_notice(&device->dev, 274 "ib_register_mad_agent: No OUI specified for class 0x%x\n", 275 mad_reg_req->mgmt_class); 276 goto error1; 277 } 278 } 279 /* Make sure class supplied is consistent with RMPP */ 280 if (!ib_is_mad_class_rmpp(mad_reg_req->mgmt_class)) { 281 if (rmpp_version) { 282 dev_notice(&device->dev, 283 "ib_register_mad_agent: RMPP version for non-RMPP class 0x%x\n", 284 mad_reg_req->mgmt_class); 285 goto error1; 286 } 287 } 288 289 /* Make sure class supplied is consistent with QP type */ 290 if (qp_type == IB_QPT_SMI) { 291 if ((mad_reg_req->mgmt_class != 292 IB_MGMT_CLASS_SUBN_LID_ROUTED) && 293 (mad_reg_req->mgmt_class != 294 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)) { 295 dev_notice(&device->dev, 296 "ib_register_mad_agent: Invalid SM QP type: class 0x%x\n", 297 mad_reg_req->mgmt_class); 298 goto error1; 299 } 300 } else { 301 if ((mad_reg_req->mgmt_class == 302 IB_MGMT_CLASS_SUBN_LID_ROUTED) || 303 (mad_reg_req->mgmt_class == 304 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)) { 305 dev_notice(&device->dev, 306 "ib_register_mad_agent: Invalid GS QP type: class 0x%x\n", 307 mad_reg_req->mgmt_class); 308 goto error1; 309 } 310 } 311 } else { 312 /* No registration request supplied */ 313 if (!send_handler) 314 goto error1; 315 if (registration_flags & IB_MAD_USER_RMPP) 316 goto error1; 317 } 318 319 /* Validate device and port */ 320 port_priv = ib_get_mad_port(device, port_num); 321 if (!port_priv) { 322 dev_notice(&device->dev, "ib_register_mad_agent: Invalid port\n"); 323 ret = ERR_PTR(-ENODEV); 324 goto error1; 325 } 326 327 /* Verify the QP requested is supported. For example, Ethernet devices 328 * will not have QP0 */ 329 if (!port_priv->qp_info[qpn].qp) { 330 dev_notice(&device->dev, 331 "ib_register_mad_agent: QP %d not supported\n", qpn); 332 ret = ERR_PTR(-EPROTONOSUPPORT); 333 goto error1; 334 } 335 336 /* Allocate structures */ 337 mad_agent_priv = kzalloc(sizeof *mad_agent_priv, GFP_KERNEL); 338 if (!mad_agent_priv) { 339 ret = ERR_PTR(-ENOMEM); 340 goto error1; 341 } 342 343 if (mad_reg_req) { 344 reg_req = kmemdup(mad_reg_req, sizeof *reg_req, GFP_KERNEL); 345 if (!reg_req) { 346 ret = ERR_PTR(-ENOMEM); 347 goto error3; 348 } 349 } 350 351 /* Now, fill in the various structures */ 352 mad_agent_priv->qp_info = &port_priv->qp_info[qpn]; 353 mad_agent_priv->reg_req = reg_req; 354 mad_agent_priv->agent.rmpp_version = rmpp_version; 355 mad_agent_priv->agent.device = device; 356 mad_agent_priv->agent.recv_handler = recv_handler; 357 mad_agent_priv->agent.send_handler = send_handler; 358 mad_agent_priv->agent.context = context; 359 mad_agent_priv->agent.qp = port_priv->qp_info[qpn].qp; 360 mad_agent_priv->agent.port_num = port_num; 361 mad_agent_priv->agent.flags = registration_flags; 362 spin_lock_init(&mad_agent_priv->lock); 363 INIT_LIST_HEAD(&mad_agent_priv->send_list); 364 INIT_LIST_HEAD(&mad_agent_priv->wait_list); 365 INIT_LIST_HEAD(&mad_agent_priv->done_list); 366 INIT_LIST_HEAD(&mad_agent_priv->rmpp_list); 367 INIT_DELAYED_WORK(&mad_agent_priv->timed_work, timeout_sends); 368 INIT_LIST_HEAD(&mad_agent_priv->local_list); 369 INIT_WORK(&mad_agent_priv->local_work, local_completions); 370 atomic_set(&mad_agent_priv->refcount, 1); 371 init_completion(&mad_agent_priv->comp); 372 373 spin_lock_irqsave(&port_priv->reg_lock, flags); 374 mad_agent_priv->agent.hi_tid = ++ib_mad_client_id; 375 376 /* 377 * Make sure MAD registration (if supplied) 378 * is non overlapping with any existing ones 379 */ 380 if (mad_reg_req) { 381 mgmt_class = convert_mgmt_class(mad_reg_req->mgmt_class); 382 if (!is_vendor_class(mgmt_class)) { 383 class = port_priv->version[mad_reg_req-> 384 mgmt_class_version].class; 385 if (class) { 386 method = class->method_table[mgmt_class]; 387 if (method) { 388 if (method_in_use(&method, 389 mad_reg_req)) 390 goto error4; 391 } 392 } 393 ret2 = add_nonoui_reg_req(mad_reg_req, mad_agent_priv, 394 mgmt_class); 395 } else { 396 /* "New" vendor class range */ 397 vendor = port_priv->version[mad_reg_req-> 398 mgmt_class_version].vendor; 399 if (vendor) { 400 vclass = vendor_class_index(mgmt_class); 401 vendor_class = vendor->vendor_class[vclass]; 402 if (vendor_class) { 403 if (is_vendor_method_in_use( 404 vendor_class, 405 mad_reg_req)) 406 goto error4; 407 } 408 } 409 ret2 = add_oui_reg_req(mad_reg_req, mad_agent_priv); 410 } 411 if (ret2) { 412 ret = ERR_PTR(ret2); 413 goto error4; 414 } 415 } 416 417 /* Add mad agent into port's agent list */ 418 list_add_tail(&mad_agent_priv->agent_list, &port_priv->agent_list); 419 spin_unlock_irqrestore(&port_priv->reg_lock, flags); 420 421 return &mad_agent_priv->agent; 422 423error4: 424 spin_unlock_irqrestore(&port_priv->reg_lock, flags); 425 kfree(reg_req); 426error3: 427 kfree(mad_agent_priv); 428error1: 429 return ret; 430} 431EXPORT_SYMBOL(ib_register_mad_agent); 432 433static inline int is_snooping_sends(int mad_snoop_flags) 434{ 435 return (mad_snoop_flags & 436 (/*IB_MAD_SNOOP_POSTED_SENDS | 437 IB_MAD_SNOOP_RMPP_SENDS |*/ 438 IB_MAD_SNOOP_SEND_COMPLETIONS /*| 439 IB_MAD_SNOOP_RMPP_SEND_COMPLETIONS*/)); 440} 441 442static inline int is_snooping_recvs(int mad_snoop_flags) 443{ 444 return (mad_snoop_flags & 445 (IB_MAD_SNOOP_RECVS /*| 446 IB_MAD_SNOOP_RMPP_RECVS*/)); 447} 448 449static int register_snoop_agent(struct ib_mad_qp_info *qp_info, 450 struct ib_mad_snoop_private *mad_snoop_priv) 451{ 452 struct ib_mad_snoop_private **new_snoop_table; 453 unsigned long flags; 454 int i; 455 456 spin_lock_irqsave(&qp_info->snoop_lock, flags); 457 /* Check for empty slot in array. */ 458 for (i = 0; i < qp_info->snoop_table_size; i++) 459 if (!qp_info->snoop_table[i]) 460 break; 461 462 if (i == qp_info->snoop_table_size) { 463 /* Grow table. */ 464 new_snoop_table = krealloc(qp_info->snoop_table, 465 sizeof mad_snoop_priv * 466 (qp_info->snoop_table_size + 1), 467 GFP_ATOMIC); 468 if (!new_snoop_table) { 469 i = -ENOMEM; 470 goto out; 471 } 472 473 qp_info->snoop_table = new_snoop_table; 474 qp_info->snoop_table_size++; 475 } 476 qp_info->snoop_table[i] = mad_snoop_priv; 477 atomic_inc(&qp_info->snoop_count); 478out: 479 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 480 return i; 481} 482 483struct ib_mad_agent *ib_register_mad_snoop(struct ib_device *device, 484 u8 port_num, 485 enum ib_qp_type qp_type, 486 int mad_snoop_flags, 487 ib_mad_snoop_handler snoop_handler, 488 ib_mad_recv_handler recv_handler, 489 void *context) 490{ 491 struct ib_mad_port_private *port_priv; 492 struct ib_mad_agent *ret; 493 struct ib_mad_snoop_private *mad_snoop_priv; 494 int qpn; 495 496 /* Validate parameters */ 497 if ((is_snooping_sends(mad_snoop_flags) && !snoop_handler) || 498 (is_snooping_recvs(mad_snoop_flags) && !recv_handler)) { 499 ret = ERR_PTR(-EINVAL); 500 goto error1; 501 } 502 qpn = get_spl_qp_index(qp_type); 503 if (qpn == -1) { 504 ret = ERR_PTR(-EINVAL); 505 goto error1; 506 } 507 port_priv = ib_get_mad_port(device, port_num); 508 if (!port_priv) { 509 ret = ERR_PTR(-ENODEV); 510 goto error1; 511 } 512 /* Allocate structures */ 513 mad_snoop_priv = kzalloc(sizeof *mad_snoop_priv, GFP_KERNEL); 514 if (!mad_snoop_priv) { 515 ret = ERR_PTR(-ENOMEM); 516 goto error1; 517 } 518 519 /* Now, fill in the various structures */ 520 mad_snoop_priv->qp_info = &port_priv->qp_info[qpn]; 521 mad_snoop_priv->agent.device = device; 522 mad_snoop_priv->agent.recv_handler = recv_handler; 523 mad_snoop_priv->agent.snoop_handler = snoop_handler; 524 mad_snoop_priv->agent.context = context; 525 mad_snoop_priv->agent.qp = port_priv->qp_info[qpn].qp; 526 mad_snoop_priv->agent.port_num = port_num; 527 mad_snoop_priv->mad_snoop_flags = mad_snoop_flags; 528 init_completion(&mad_snoop_priv->comp); 529 mad_snoop_priv->snoop_index = register_snoop_agent( 530 &port_priv->qp_info[qpn], 531 mad_snoop_priv); 532 if (mad_snoop_priv->snoop_index < 0) { 533 ret = ERR_PTR(mad_snoop_priv->snoop_index); 534 goto error2; 535 } 536 537 atomic_set(&mad_snoop_priv->refcount, 1); 538 return &mad_snoop_priv->agent; 539 540error2: 541 kfree(mad_snoop_priv); 542error1: 543 return ret; 544} 545EXPORT_SYMBOL(ib_register_mad_snoop); 546 547static inline void deref_mad_agent(struct ib_mad_agent_private *mad_agent_priv) 548{ 549 if (atomic_dec_and_test(&mad_agent_priv->refcount)) 550 complete(&mad_agent_priv->comp); 551} 552 553static inline void deref_snoop_agent(struct ib_mad_snoop_private *mad_snoop_priv) 554{ 555 if (atomic_dec_and_test(&mad_snoop_priv->refcount)) 556 complete(&mad_snoop_priv->comp); 557} 558 559static void unregister_mad_agent(struct ib_mad_agent_private *mad_agent_priv) 560{ 561 struct ib_mad_port_private *port_priv; 562 unsigned long flags; 563 564 /* Note that we could still be handling received MADs */ 565 566 /* 567 * Canceling all sends results in dropping received response 568 * MADs, preventing us from queuing additional work 569 */ 570 cancel_mads(mad_agent_priv); 571 port_priv = mad_agent_priv->qp_info->port_priv; 572 cancel_delayed_work(&mad_agent_priv->timed_work); 573 574 spin_lock_irqsave(&port_priv->reg_lock, flags); 575 remove_mad_reg_req(mad_agent_priv); 576 list_del(&mad_agent_priv->agent_list); 577 spin_unlock_irqrestore(&port_priv->reg_lock, flags); 578 579 flush_workqueue(port_priv->wq); 580 ib_cancel_rmpp_recvs(mad_agent_priv); 581 582 deref_mad_agent(mad_agent_priv); 583 wait_for_completion(&mad_agent_priv->comp); 584 585 kfree(mad_agent_priv->reg_req); 586 kfree(mad_agent_priv); 587} 588 589static void unregister_mad_snoop(struct ib_mad_snoop_private *mad_snoop_priv) 590{ 591 struct ib_mad_qp_info *qp_info; 592 unsigned long flags; 593 594 qp_info = mad_snoop_priv->qp_info; 595 spin_lock_irqsave(&qp_info->snoop_lock, flags); 596 qp_info->snoop_table[mad_snoop_priv->snoop_index] = NULL; 597 atomic_dec(&qp_info->snoop_count); 598 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 599 600 deref_snoop_agent(mad_snoop_priv); 601 wait_for_completion(&mad_snoop_priv->comp); 602 603 kfree(mad_snoop_priv); 604} 605 606/* 607 * ib_unregister_mad_agent - Unregisters a client from using MAD services 608 */ 609int ib_unregister_mad_agent(struct ib_mad_agent *mad_agent) 610{ 611 struct ib_mad_agent_private *mad_agent_priv; 612 struct ib_mad_snoop_private *mad_snoop_priv; 613 614 /* If the TID is zero, the agent can only snoop. */ 615 if (mad_agent->hi_tid) { 616 mad_agent_priv = container_of(mad_agent, 617 struct ib_mad_agent_private, 618 agent); 619 unregister_mad_agent(mad_agent_priv); 620 } else { 621 mad_snoop_priv = container_of(mad_agent, 622 struct ib_mad_snoop_private, 623 agent); 624 unregister_mad_snoop(mad_snoop_priv); 625 } 626 return 0; 627} 628EXPORT_SYMBOL(ib_unregister_mad_agent); 629 630static void dequeue_mad(struct ib_mad_list_head *mad_list) 631{ 632 struct ib_mad_queue *mad_queue; 633 unsigned long flags; 634 635 BUG_ON(!mad_list->mad_queue); 636 mad_queue = mad_list->mad_queue; 637 spin_lock_irqsave(&mad_queue->lock, flags); 638 list_del(&mad_list->list); 639 mad_queue->count--; 640 spin_unlock_irqrestore(&mad_queue->lock, flags); 641} 642 643static void snoop_send(struct ib_mad_qp_info *qp_info, 644 struct ib_mad_send_buf *send_buf, 645 struct ib_mad_send_wc *mad_send_wc, 646 int mad_snoop_flags) 647{ 648 struct ib_mad_snoop_private *mad_snoop_priv; 649 unsigned long flags; 650 int i; 651 652 spin_lock_irqsave(&qp_info->snoop_lock, flags); 653 for (i = 0; i < qp_info->snoop_table_size; i++) { 654 mad_snoop_priv = qp_info->snoop_table[i]; 655 if (!mad_snoop_priv || 656 !(mad_snoop_priv->mad_snoop_flags & mad_snoop_flags)) 657 continue; 658 659 atomic_inc(&mad_snoop_priv->refcount); 660 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 661 mad_snoop_priv->agent.snoop_handler(&mad_snoop_priv->agent, 662 send_buf, mad_send_wc); 663 deref_snoop_agent(mad_snoop_priv); 664 spin_lock_irqsave(&qp_info->snoop_lock, flags); 665 } 666 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 667} 668 669static void snoop_recv(struct ib_mad_qp_info *qp_info, 670 struct ib_mad_recv_wc *mad_recv_wc, 671 int mad_snoop_flags) 672{ 673 struct ib_mad_snoop_private *mad_snoop_priv; 674 unsigned long flags; 675 int i; 676 677 spin_lock_irqsave(&qp_info->snoop_lock, flags); 678 for (i = 0; i < qp_info->snoop_table_size; i++) { 679 mad_snoop_priv = qp_info->snoop_table[i]; 680 if (!mad_snoop_priv || 681 !(mad_snoop_priv->mad_snoop_flags & mad_snoop_flags)) 682 continue; 683 684 atomic_inc(&mad_snoop_priv->refcount); 685 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 686 mad_snoop_priv->agent.recv_handler(&mad_snoop_priv->agent, NULL, 687 mad_recv_wc); 688 deref_snoop_agent(mad_snoop_priv); 689 spin_lock_irqsave(&qp_info->snoop_lock, flags); 690 } 691 spin_unlock_irqrestore(&qp_info->snoop_lock, flags); 692} 693 694static void build_smp_wc(struct ib_qp *qp, struct ib_cqe *cqe, u16 slid, 695 u16 pkey_index, u8 port_num, struct ib_wc *wc) 696{ 697 memset(wc, 0, sizeof *wc); 698 wc->wr_cqe = cqe; 699 wc->status = IB_WC_SUCCESS; 700 wc->opcode = IB_WC_RECV; 701 wc->pkey_index = pkey_index; 702 wc->byte_len = sizeof(struct ib_mad) + sizeof(struct ib_grh); 703 wc->src_qp = IB_QP0; 704 wc->qp = qp; 705 wc->slid = slid; 706 wc->sl = 0; 707 wc->dlid_path_bits = 0; 708 wc->port_num = port_num; 709} 710 711static size_t mad_priv_size(const struct ib_mad_private *mp) 712{ 713 return sizeof(struct ib_mad_private) + mp->mad_size; 714} 715 716static struct ib_mad_private *alloc_mad_private(size_t mad_size, gfp_t flags) 717{ 718 size_t size = sizeof(struct ib_mad_private) + mad_size; 719 struct ib_mad_private *ret = kzalloc(size, flags); 720 721 if (ret) 722 ret->mad_size = mad_size; 723 724 return ret; 725} 726 727static size_t port_mad_size(const struct ib_mad_port_private *port_priv) 728{ 729 return rdma_max_mad_size(port_priv->device, port_priv->port_num); 730} 731 732static size_t mad_priv_dma_size(const struct ib_mad_private *mp) 733{ 734 return sizeof(struct ib_grh) + mp->mad_size; 735} 736 737/* 738 * Return 0 if SMP is to be sent 739 * Return 1 if SMP was consumed locally (whether or not solicited) 740 * Return < 0 if error 741 */ 742static int handle_outgoing_dr_smp(struct ib_mad_agent_private *mad_agent_priv, 743 struct ib_mad_send_wr_private *mad_send_wr) 744{ 745 int ret = 0; 746 struct ib_smp *smp = mad_send_wr->send_buf.mad; 747 struct opa_smp *opa_smp = (struct opa_smp *)smp; 748 unsigned long flags; 749 struct ib_mad_local_private *local; 750 struct ib_mad_private *mad_priv; 751 struct ib_mad_port_private *port_priv; 752 struct ib_mad_agent_private *recv_mad_agent = NULL; 753 struct ib_device *device = mad_agent_priv->agent.device; 754 u8 port_num; 755 struct ib_wc mad_wc; 756 struct ib_ud_wr *send_wr = &mad_send_wr->send_wr; 757 size_t mad_size = port_mad_size(mad_agent_priv->qp_info->port_priv); 758 u16 out_mad_pkey_index = 0; 759 u16 drslid; 760 bool opa = rdma_cap_opa_mad(mad_agent_priv->qp_info->port_priv->device, 761 mad_agent_priv->qp_info->port_priv->port_num); 762 763 if (rdma_cap_ib_switch(device) && 764 smp->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) 765 port_num = send_wr->port_num; 766 else 767 port_num = mad_agent_priv->agent.port_num; 768 769 /* 770 * Directed route handling starts if the initial LID routed part of 771 * a request or the ending LID routed part of a response is empty. 772 * If we are at the start of the LID routed part, don't update the 773 * hop_ptr or hop_cnt. See section 14.2.2, Vol 1 IB spec. 774 */ 775 if (opa && smp->class_version == OPA_SMP_CLASS_VERSION) { 776 u32 opa_drslid; 777 778 if ((opa_get_smp_direction(opa_smp) 779 ? opa_smp->route.dr.dr_dlid : opa_smp->route.dr.dr_slid) == 780 OPA_LID_PERMISSIVE && 781 opa_smi_handle_dr_smp_send(opa_smp, 782 rdma_cap_ib_switch(device), 783 port_num) == IB_SMI_DISCARD) { 784 ret = -EINVAL; 785 dev_err(&device->dev, "OPA Invalid directed route\n"); 786 goto out; 787 } 788 opa_drslid = be32_to_cpu(opa_smp->route.dr.dr_slid); 789 if (opa_drslid != be32_to_cpu(OPA_LID_PERMISSIVE) && 790 opa_drslid & 0xffff0000) { 791 ret = -EINVAL; 792 dev_err(&device->dev, "OPA Invalid dr_slid 0x%x\n", 793 opa_drslid); 794 goto out; 795 } 796 drslid = (u16)(opa_drslid & 0x0000ffff); 797 798 /* Check to post send on QP or process locally */ 799 if (opa_smi_check_local_smp(opa_smp, device) == IB_SMI_DISCARD && 800 opa_smi_check_local_returning_smp(opa_smp, device) == IB_SMI_DISCARD) 801 goto out; 802 } else { 803 if ((ib_get_smp_direction(smp) ? smp->dr_dlid : smp->dr_slid) == 804 IB_LID_PERMISSIVE && 805 smi_handle_dr_smp_send(smp, rdma_cap_ib_switch(device), port_num) == 806 IB_SMI_DISCARD) { 807 ret = -EINVAL; 808 dev_err(&device->dev, "Invalid directed route\n"); 809 goto out; 810 } 811 drslid = be16_to_cpu(smp->dr_slid); 812 813 /* Check to post send on QP or process locally */ 814 if (smi_check_local_smp(smp, device) == IB_SMI_DISCARD && 815 smi_check_local_returning_smp(smp, device) == IB_SMI_DISCARD) 816 goto out; 817 } 818 819 local = kmalloc(sizeof *local, GFP_ATOMIC); 820 if (!local) { 821 ret = -ENOMEM; 822 dev_err(&device->dev, "No memory for ib_mad_local_private\n"); 823 goto out; 824 } 825 local->mad_priv = NULL; 826 local->recv_mad_agent = NULL; 827 mad_priv = alloc_mad_private(mad_size, GFP_ATOMIC); 828 if (!mad_priv) { 829 ret = -ENOMEM; 830 dev_err(&device->dev, "No memory for local response MAD\n"); 831 kfree(local); 832 goto out; 833 } 834 835 build_smp_wc(mad_agent_priv->agent.qp, 836 send_wr->wr.wr_cqe, drslid, 837 send_wr->pkey_index, 838 send_wr->port_num, &mad_wc); 839 840 if (opa && smp->base_version == OPA_MGMT_BASE_VERSION) { 841 mad_wc.byte_len = mad_send_wr->send_buf.hdr_len 842 + mad_send_wr->send_buf.data_len 843 + sizeof(struct ib_grh); 844 } 845 846 /* No GRH for DR SMP */ 847 ret = device->process_mad(device, 0, port_num, &mad_wc, NULL, 848 (const struct ib_mad_hdr *)smp, mad_size, 849 (struct ib_mad_hdr *)mad_priv->mad, 850 &mad_size, &out_mad_pkey_index); 851 switch (ret) 852 { 853 case IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_REPLY: 854 if (ib_response_mad((const struct ib_mad_hdr *)mad_priv->mad) && 855 mad_agent_priv->agent.recv_handler) { 856 local->mad_priv = mad_priv; 857 local->recv_mad_agent = mad_agent_priv; 858 /* 859 * Reference MAD agent until receive 860 * side of local completion handled 861 */ 862 atomic_inc(&mad_agent_priv->refcount); 863 } else 864 kfree(mad_priv); 865 break; 866 case IB_MAD_RESULT_SUCCESS | IB_MAD_RESULT_CONSUMED: 867 kfree(mad_priv); 868 break; 869 case IB_MAD_RESULT_SUCCESS: 870 /* Treat like an incoming receive MAD */ 871 port_priv = ib_get_mad_port(mad_agent_priv->agent.device, 872 mad_agent_priv->agent.port_num); 873 if (port_priv) { 874 memcpy(mad_priv->mad, smp, mad_priv->mad_size); 875 recv_mad_agent = find_mad_agent(port_priv, 876 (const struct ib_mad_hdr *)mad_priv->mad); 877 } 878 if (!port_priv || !recv_mad_agent) { 879 /* 880 * No receiving agent so drop packet and 881 * generate send completion. 882 */ 883 kfree(mad_priv); 884 break; 885 } 886 local->mad_priv = mad_priv; 887 local->recv_mad_agent = recv_mad_agent; 888 break; 889 default: 890 kfree(mad_priv); 891 kfree(local); 892 ret = -EINVAL; 893 goto out; 894 } 895 896 local->mad_send_wr = mad_send_wr; 897 if (opa) { 898 local->mad_send_wr->send_wr.pkey_index = out_mad_pkey_index; 899 local->return_wc_byte_len = mad_size; 900 } 901 /* Reference MAD agent until send side of local completion handled */ 902 atomic_inc(&mad_agent_priv->refcount); 903 /* Queue local completion to local list */ 904 spin_lock_irqsave(&mad_agent_priv->lock, flags); 905 list_add_tail(&local->completion_list, &mad_agent_priv->local_list); 906 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 907 queue_work(mad_agent_priv->qp_info->port_priv->wq, 908 &mad_agent_priv->local_work); 909 ret = 1; 910out: 911 return ret; 912} 913 914static int get_pad_size(int hdr_len, int data_len, size_t mad_size) 915{ 916 int seg_size, pad; 917 918 seg_size = mad_size - hdr_len; 919 if (data_len && seg_size) { 920 pad = seg_size - data_len % seg_size; 921 return pad == seg_size ? 0 : pad; 922 } else 923 return seg_size; 924} 925 926static void free_send_rmpp_list(struct ib_mad_send_wr_private *mad_send_wr) 927{ 928 struct ib_rmpp_segment *s, *t; 929 930 list_for_each_entry_safe(s, t, &mad_send_wr->rmpp_list, list) { 931 list_del(&s->list); 932 kfree(s); 933 } 934} 935 936static int alloc_send_rmpp_list(struct ib_mad_send_wr_private *send_wr, 937 size_t mad_size, gfp_t gfp_mask) 938{ 939 struct ib_mad_send_buf *send_buf = &send_wr->send_buf; 940 struct ib_rmpp_mad *rmpp_mad = send_buf->mad; 941 struct ib_rmpp_segment *seg = NULL; 942 int left, seg_size, pad; 943 944 send_buf->seg_size = mad_size - send_buf->hdr_len; 945 send_buf->seg_rmpp_size = mad_size - IB_MGMT_RMPP_HDR; 946 seg_size = send_buf->seg_size; 947 pad = send_wr->pad; 948 949 /* Allocate data segments. */ 950 for (left = send_buf->data_len + pad; left > 0; left -= seg_size) { 951 seg = kmalloc(sizeof (*seg) + seg_size, gfp_mask); 952 if (!seg) { 953 dev_err(&send_buf->mad_agent->device->dev, 954 "alloc_send_rmpp_segs: RMPP mem alloc failed for len %zd, gfp %#x\n", 955 sizeof (*seg) + seg_size, gfp_mask); 956 free_send_rmpp_list(send_wr); 957 return -ENOMEM; 958 } 959 seg->num = ++send_buf->seg_count; 960 list_add_tail(&seg->list, &send_wr->rmpp_list); 961 } 962 963 /* Zero any padding */ 964 if (pad) 965 memset(seg->data + seg_size - pad, 0, pad); 966 967 rmpp_mad->rmpp_hdr.rmpp_version = send_wr->mad_agent_priv-> 968 agent.rmpp_version; 969 rmpp_mad->rmpp_hdr.rmpp_type = IB_MGMT_RMPP_TYPE_DATA; 970 ib_set_rmpp_flags(&rmpp_mad->rmpp_hdr, IB_MGMT_RMPP_FLAG_ACTIVE); 971 972 send_wr->cur_seg = container_of(send_wr->rmpp_list.next, 973 struct ib_rmpp_segment, list); 974 send_wr->last_ack_seg = send_wr->cur_seg; 975 return 0; 976} 977 978int ib_mad_kernel_rmpp_agent(const struct ib_mad_agent *agent) 979{ 980 return agent->rmpp_version && !(agent->flags & IB_MAD_USER_RMPP); 981} 982EXPORT_SYMBOL(ib_mad_kernel_rmpp_agent); 983 984struct ib_mad_send_buf * ib_create_send_mad(struct ib_mad_agent *mad_agent, 985 u32 remote_qpn, u16 pkey_index, 986 int rmpp_active, 987 int hdr_len, int data_len, 988 gfp_t gfp_mask, 989 u8 base_version) 990{ 991 struct ib_mad_agent_private *mad_agent_priv; 992 struct ib_mad_send_wr_private *mad_send_wr; 993 int pad, message_size, ret, size; 994 void *buf; 995 size_t mad_size; 996 bool opa; 997 998 mad_agent_priv = container_of(mad_agent, struct ib_mad_agent_private, 999 agent); 1000 1001 opa = rdma_cap_opa_mad(mad_agent->device, mad_agent->port_num); 1002 1003 if (opa && base_version == OPA_MGMT_BASE_VERSION) 1004 mad_size = sizeof(struct opa_mad); 1005 else 1006 mad_size = sizeof(struct ib_mad); 1007 1008 pad = get_pad_size(hdr_len, data_len, mad_size); 1009 message_size = hdr_len + data_len + pad; 1010 1011 if (ib_mad_kernel_rmpp_agent(mad_agent)) { 1012 if (!rmpp_active && message_size > mad_size) 1013 return ERR_PTR(-EINVAL); 1014 } else 1015 if (rmpp_active || message_size > mad_size) 1016 return ERR_PTR(-EINVAL); 1017 1018 size = rmpp_active ? hdr_len : mad_size; 1019 buf = kzalloc(sizeof *mad_send_wr + size, gfp_mask); 1020 if (!buf) 1021 return ERR_PTR(-ENOMEM); 1022 1023 mad_send_wr = (struct ib_mad_send_wr_private *)((char *)buf + size); 1024 INIT_LIST_HEAD(&mad_send_wr->rmpp_list); 1025 mad_send_wr->send_buf.mad = buf; 1026 mad_send_wr->send_buf.hdr_len = hdr_len; 1027 mad_send_wr->send_buf.data_len = data_len; 1028 mad_send_wr->pad = pad; 1029 1030 mad_send_wr->mad_agent_priv = mad_agent_priv; 1031 mad_send_wr->sg_list[0].length = hdr_len; 1032 mad_send_wr->sg_list[0].lkey = mad_agent->qp->pd->local_dma_lkey; 1033 1034 /* OPA MADs don't have to be the full 2048 bytes */ 1035 if (opa && base_version == OPA_MGMT_BASE_VERSION && 1036 data_len < mad_size - hdr_len) 1037 mad_send_wr->sg_list[1].length = data_len; 1038 else 1039 mad_send_wr->sg_list[1].length = mad_size - hdr_len; 1040 1041 mad_send_wr->sg_list[1].lkey = mad_agent->qp->pd->local_dma_lkey; 1042 1043 mad_send_wr->mad_list.cqe.done = ib_mad_send_done; 1044 1045 mad_send_wr->send_wr.wr.wr_cqe = &mad_send_wr->mad_list.cqe; 1046 mad_send_wr->send_wr.wr.sg_list = mad_send_wr->sg_list; 1047 mad_send_wr->send_wr.wr.num_sge = 2; 1048 mad_send_wr->send_wr.wr.opcode = IB_WR_SEND; 1049 mad_send_wr->send_wr.wr.send_flags = IB_SEND_SIGNALED; 1050 mad_send_wr->send_wr.remote_qpn = remote_qpn; 1051 mad_send_wr->send_wr.remote_qkey = IB_QP_SET_QKEY; 1052 mad_send_wr->send_wr.pkey_index = pkey_index; 1053 1054 if (rmpp_active) { 1055 ret = alloc_send_rmpp_list(mad_send_wr, mad_size, gfp_mask); 1056 if (ret) { 1057 kfree(buf); 1058 return ERR_PTR(ret); 1059 } 1060 } 1061 1062 mad_send_wr->send_buf.mad_agent = mad_agent; 1063 atomic_inc(&mad_agent_priv->refcount); 1064 return &mad_send_wr->send_buf; 1065} 1066EXPORT_SYMBOL(ib_create_send_mad); 1067 1068int ib_get_mad_data_offset(u8 mgmt_class) 1069{ 1070 if (mgmt_class == IB_MGMT_CLASS_SUBN_ADM) 1071 return IB_MGMT_SA_HDR; 1072 else if ((mgmt_class == IB_MGMT_CLASS_DEVICE_MGMT) || 1073 (mgmt_class == IB_MGMT_CLASS_DEVICE_ADM) || 1074 (mgmt_class == IB_MGMT_CLASS_BIS)) 1075 return IB_MGMT_DEVICE_HDR; 1076 else if ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) && 1077 (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END)) 1078 return IB_MGMT_VENDOR_HDR; 1079 else 1080 return IB_MGMT_MAD_HDR; 1081} 1082EXPORT_SYMBOL(ib_get_mad_data_offset); 1083 1084int ib_is_mad_class_rmpp(u8 mgmt_class) 1085{ 1086 if ((mgmt_class == IB_MGMT_CLASS_SUBN_ADM) || 1087 (mgmt_class == IB_MGMT_CLASS_DEVICE_MGMT) || 1088 (mgmt_class == IB_MGMT_CLASS_DEVICE_ADM) || 1089 (mgmt_class == IB_MGMT_CLASS_BIS) || 1090 ((mgmt_class >= IB_MGMT_CLASS_VENDOR_RANGE2_START) && 1091 (mgmt_class <= IB_MGMT_CLASS_VENDOR_RANGE2_END))) 1092 return 1; 1093 return 0; 1094} 1095EXPORT_SYMBOL(ib_is_mad_class_rmpp); 1096 1097void *ib_get_rmpp_segment(struct ib_mad_send_buf *send_buf, int seg_num) 1098{ 1099 struct ib_mad_send_wr_private *mad_send_wr; 1100 struct list_head *list; 1101 1102 mad_send_wr = container_of(send_buf, struct ib_mad_send_wr_private, 1103 send_buf); 1104 list = &mad_send_wr->cur_seg->list; 1105 1106 if (mad_send_wr->cur_seg->num < seg_num) { 1107 list_for_each_entry(mad_send_wr->cur_seg, list, list) 1108 if (mad_send_wr->cur_seg->num == seg_num) 1109 break; 1110 } else if (mad_send_wr->cur_seg->num > seg_num) { 1111 list_for_each_entry_reverse(mad_send_wr->cur_seg, list, list) 1112 if (mad_send_wr->cur_seg->num == seg_num) 1113 break; 1114 } 1115 return mad_send_wr->cur_seg->data; 1116} 1117EXPORT_SYMBOL(ib_get_rmpp_segment); 1118 1119static inline void *ib_get_payload(struct ib_mad_send_wr_private *mad_send_wr) 1120{ 1121 if (mad_send_wr->send_buf.seg_count) 1122 return ib_get_rmpp_segment(&mad_send_wr->send_buf, 1123 mad_send_wr->seg_num); 1124 else 1125 return (char *)mad_send_wr->send_buf.mad + 1126 mad_send_wr->send_buf.hdr_len; 1127} 1128 1129void ib_free_send_mad(struct ib_mad_send_buf *send_buf) 1130{ 1131 struct ib_mad_agent_private *mad_agent_priv; 1132 struct ib_mad_send_wr_private *mad_send_wr; 1133 1134 mad_agent_priv = container_of(send_buf->mad_agent, 1135 struct ib_mad_agent_private, agent); 1136 mad_send_wr = container_of(send_buf, struct ib_mad_send_wr_private, 1137 send_buf); 1138 1139 free_send_rmpp_list(mad_send_wr); 1140 kfree(send_buf->mad); 1141 deref_mad_agent(mad_agent_priv); 1142} 1143EXPORT_SYMBOL(ib_free_send_mad); 1144 1145int ib_send_mad(struct ib_mad_send_wr_private *mad_send_wr) 1146{ 1147 struct ib_mad_qp_info *qp_info; 1148 struct list_head *list; 1149 struct ib_send_wr *bad_send_wr; 1150 struct ib_mad_agent *mad_agent; 1151 struct ib_sge *sge; 1152 unsigned long flags; 1153 int ret; 1154 1155 /* Set WR ID to find mad_send_wr upon completion */ 1156 qp_info = mad_send_wr->mad_agent_priv->qp_info; 1157 mad_send_wr->mad_list.mad_queue = &qp_info->send_queue; 1158 mad_send_wr->mad_list.cqe.done = ib_mad_send_done; 1159 mad_send_wr->send_wr.wr.wr_cqe = &mad_send_wr->mad_list.cqe; 1160 1161 mad_agent = mad_send_wr->send_buf.mad_agent; 1162 sge = mad_send_wr->sg_list; 1163 sge[0].addr = ib_dma_map_single(mad_agent->device, 1164 mad_send_wr->send_buf.mad, 1165 sge[0].length, 1166 DMA_TO_DEVICE); 1167 if (unlikely(ib_dma_mapping_error(mad_agent->device, sge[0].addr))) 1168 return -ENOMEM; 1169 1170 mad_send_wr->header_mapping = sge[0].addr; 1171 1172 sge[1].addr = ib_dma_map_single(mad_agent->device, 1173 ib_get_payload(mad_send_wr), 1174 sge[1].length, 1175 DMA_TO_DEVICE); 1176 if (unlikely(ib_dma_mapping_error(mad_agent->device, sge[1].addr))) { 1177 ib_dma_unmap_single(mad_agent->device, 1178 mad_send_wr->header_mapping, 1179 sge[0].length, DMA_TO_DEVICE); 1180 return -ENOMEM; 1181 } 1182 mad_send_wr->payload_mapping = sge[1].addr; 1183 1184 spin_lock_irqsave(&qp_info->send_queue.lock, flags); 1185 if (qp_info->send_queue.count < qp_info->send_queue.max_active) { 1186 ret = ib_post_send(mad_agent->qp, &mad_send_wr->send_wr.wr, 1187 &bad_send_wr); 1188 list = &qp_info->send_queue.list; 1189 } else { 1190 ret = 0; 1191 list = &qp_info->overflow_list; 1192 } 1193 1194 if (!ret) { 1195 qp_info->send_queue.count++; 1196 list_add_tail(&mad_send_wr->mad_list.list, list); 1197 } 1198 spin_unlock_irqrestore(&qp_info->send_queue.lock, flags); 1199 if (ret) { 1200 ib_dma_unmap_single(mad_agent->device, 1201 mad_send_wr->header_mapping, 1202 sge[0].length, DMA_TO_DEVICE); 1203 ib_dma_unmap_single(mad_agent->device, 1204 mad_send_wr->payload_mapping, 1205 sge[1].length, DMA_TO_DEVICE); 1206 } 1207 return ret; 1208} 1209 1210/* 1211 * ib_post_send_mad - Posts MAD(s) to the send queue of the QP associated 1212 * with the registered client 1213 */ 1214int ib_post_send_mad(struct ib_mad_send_buf *send_buf, 1215 struct ib_mad_send_buf **bad_send_buf) 1216{ 1217 struct ib_mad_agent_private *mad_agent_priv; 1218 struct ib_mad_send_buf *next_send_buf; 1219 struct ib_mad_send_wr_private *mad_send_wr; 1220 unsigned long flags; 1221 int ret = -EINVAL; 1222 1223 /* Walk list of send WRs and post each on send list */ 1224 for (; send_buf; send_buf = next_send_buf) { 1225 1226 mad_send_wr = container_of(send_buf, 1227 struct ib_mad_send_wr_private, 1228 send_buf); 1229 mad_agent_priv = mad_send_wr->mad_agent_priv; 1230 1231 if (!send_buf->mad_agent->send_handler || 1232 (send_buf->timeout_ms && 1233 !send_buf->mad_agent->recv_handler)) { 1234 ret = -EINVAL; 1235 goto error; 1236 } 1237 1238 if (!ib_is_mad_class_rmpp(((struct ib_mad_hdr *) send_buf->mad)->mgmt_class)) { 1239 if (mad_agent_priv->agent.rmpp_version) { 1240 ret = -EINVAL; 1241 goto error; 1242 } 1243 } 1244 1245 /* 1246 * Save pointer to next work request to post in case the 1247 * current one completes, and the user modifies the work 1248 * request associated with the completion 1249 */ 1250 next_send_buf = send_buf->next; 1251 mad_send_wr->send_wr.ah = send_buf->ah; 1252 1253 if (((struct ib_mad_hdr *) send_buf->mad)->mgmt_class == 1254 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) { 1255 ret = handle_outgoing_dr_smp(mad_agent_priv, 1256 mad_send_wr); 1257 if (ret < 0) /* error */ 1258 goto error; 1259 else if (ret == 1) /* locally consumed */ 1260 continue; 1261 } 1262 1263 mad_send_wr->tid = ((struct ib_mad_hdr *) send_buf->mad)->tid; 1264 /* Timeout will be updated after send completes */ 1265 mad_send_wr->timeout = msecs_to_jiffies(send_buf->timeout_ms); 1266 mad_send_wr->max_retries = send_buf->retries; 1267 mad_send_wr->retries_left = send_buf->retries; 1268 send_buf->retries = 0; 1269 /* Reference for work request to QP + response */ 1270 mad_send_wr->refcount = 1 + (mad_send_wr->timeout > 0); 1271 mad_send_wr->status = IB_WC_SUCCESS; 1272 1273 /* Reference MAD agent until send completes */ 1274 atomic_inc(&mad_agent_priv->refcount); 1275 spin_lock_irqsave(&mad_agent_priv->lock, flags); 1276 list_add_tail(&mad_send_wr->agent_list, 1277 &mad_agent_priv->send_list); 1278 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 1279 1280 if (ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent)) { 1281 ret = ib_send_rmpp_mad(mad_send_wr); 1282 if (ret >= 0 && ret != IB_RMPP_RESULT_CONSUMED) 1283 ret = ib_send_mad(mad_send_wr); 1284 } else 1285 ret = ib_send_mad(mad_send_wr); 1286 if (ret < 0) { 1287 /* Fail send request */ 1288 spin_lock_irqsave(&mad_agent_priv->lock, flags); 1289 list_del(&mad_send_wr->agent_list); 1290 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 1291 atomic_dec(&mad_agent_priv->refcount); 1292 goto error; 1293 } 1294 } 1295 return 0; 1296error: 1297 if (bad_send_buf) 1298 *bad_send_buf = send_buf; 1299 return ret; 1300} 1301EXPORT_SYMBOL(ib_post_send_mad); 1302 1303/* 1304 * ib_free_recv_mad - Returns data buffers used to receive 1305 * a MAD to the access layer 1306 */ 1307void ib_free_recv_mad(struct ib_mad_recv_wc *mad_recv_wc) 1308{ 1309 struct ib_mad_recv_buf *mad_recv_buf, *temp_recv_buf; 1310 struct ib_mad_private_header *mad_priv_hdr; 1311 struct ib_mad_private *priv; 1312 struct list_head free_list; 1313 1314 INIT_LIST_HEAD(&free_list); 1315 list_splice_init(&mad_recv_wc->rmpp_list, &free_list); 1316 1317 list_for_each_entry_safe(mad_recv_buf, temp_recv_buf, 1318 &free_list, list) { 1319 mad_recv_wc = container_of(mad_recv_buf, struct ib_mad_recv_wc, 1320 recv_buf); 1321 mad_priv_hdr = container_of(mad_recv_wc, 1322 struct ib_mad_private_header, 1323 recv_wc); 1324 priv = container_of(mad_priv_hdr, struct ib_mad_private, 1325 header); 1326 kfree(priv); 1327 } 1328} 1329EXPORT_SYMBOL(ib_free_recv_mad); 1330 1331struct ib_mad_agent *ib_redirect_mad_qp(struct ib_qp *qp, 1332 u8 rmpp_version, 1333 ib_mad_send_handler send_handler, 1334 ib_mad_recv_handler recv_handler, 1335 void *context) 1336{ 1337 return ERR_PTR(-EINVAL); /* XXX: for now */ 1338} 1339EXPORT_SYMBOL(ib_redirect_mad_qp); 1340 1341int ib_process_mad_wc(struct ib_mad_agent *mad_agent, 1342 struct ib_wc *wc) 1343{ 1344 dev_err(&mad_agent->device->dev, 1345 "ib_process_mad_wc() not implemented yet\n"); 1346 return 0; 1347} 1348EXPORT_SYMBOL(ib_process_mad_wc); 1349 1350static int method_in_use(struct ib_mad_mgmt_method_table **method, 1351 struct ib_mad_reg_req *mad_reg_req) 1352{ 1353 int i; 1354 1355 for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS) { 1356 if ((*method)->agent[i]) { 1357 pr_err("Method %d already in use\n", i); 1358 return -EINVAL; 1359 } 1360 } 1361 return 0; 1362} 1363 1364static int allocate_method_table(struct ib_mad_mgmt_method_table **method) 1365{ 1366 /* Allocate management method table */ 1367 *method = kzalloc(sizeof **method, GFP_ATOMIC); 1368 if (!*method) { 1369 pr_err("No memory for ib_mad_mgmt_method_table\n"); 1370 return -ENOMEM; 1371 } 1372 1373 return 0; 1374} 1375 1376/* 1377 * Check to see if there are any methods still in use 1378 */ 1379static int check_method_table(struct ib_mad_mgmt_method_table *method) 1380{ 1381 int i; 1382 1383 for (i = 0; i < IB_MGMT_MAX_METHODS; i++) 1384 if (method->agent[i]) 1385 return 1; 1386 return 0; 1387} 1388 1389/* 1390 * Check to see if there are any method tables for this class still in use 1391 */ 1392static int check_class_table(struct ib_mad_mgmt_class_table *class) 1393{ 1394 int i; 1395 1396 for (i = 0; i < MAX_MGMT_CLASS; i++) 1397 if (class->method_table[i]) 1398 return 1; 1399 return 0; 1400} 1401 1402static int check_vendor_class(struct ib_mad_mgmt_vendor_class *vendor_class) 1403{ 1404 int i; 1405 1406 for (i = 0; i < MAX_MGMT_OUI; i++) 1407 if (vendor_class->method_table[i]) 1408 return 1; 1409 return 0; 1410} 1411 1412static int find_vendor_oui(struct ib_mad_mgmt_vendor_class *vendor_class, 1413 const char *oui) 1414{ 1415 int i; 1416 1417 for (i = 0; i < MAX_MGMT_OUI; i++) 1418 /* Is there matching OUI for this vendor class ? */ 1419 if (!memcmp(vendor_class->oui[i], oui, 3)) 1420 return i; 1421 1422 return -1; 1423} 1424 1425static int check_vendor_table(struct ib_mad_mgmt_vendor_class_table *vendor) 1426{ 1427 int i; 1428 1429 for (i = 0; i < MAX_MGMT_VENDOR_RANGE2; i++) 1430 if (vendor->vendor_class[i]) 1431 return 1; 1432 1433 return 0; 1434} 1435 1436static void remove_methods_mad_agent(struct ib_mad_mgmt_method_table *method, 1437 struct ib_mad_agent_private *agent) 1438{ 1439 int i; 1440 1441 /* Remove any methods for this mad agent */ 1442 for (i = 0; i < IB_MGMT_MAX_METHODS; i++) { 1443 if (method->agent[i] == agent) { 1444 method->agent[i] = NULL; 1445 } 1446 } 1447} 1448 1449static int add_nonoui_reg_req(struct ib_mad_reg_req *mad_reg_req, 1450 struct ib_mad_agent_private *agent_priv, 1451 u8 mgmt_class) 1452{ 1453 struct ib_mad_port_private *port_priv; 1454 struct ib_mad_mgmt_class_table **class; 1455 struct ib_mad_mgmt_method_table **method; 1456 int i, ret; 1457 1458 port_priv = agent_priv->qp_info->port_priv; 1459 class = &port_priv->version[mad_reg_req->mgmt_class_version].class; 1460 if (!*class) { 1461 /* Allocate management class table for "new" class version */ 1462 *class = kzalloc(sizeof **class, GFP_ATOMIC); 1463 if (!*class) { 1464 dev_err(&agent_priv->agent.device->dev, 1465 "No memory for ib_mad_mgmt_class_table\n"); 1466 ret = -ENOMEM; 1467 goto error1; 1468 } 1469 1470 /* Allocate method table for this management class */ 1471 method = &(*class)->method_table[mgmt_class]; 1472 if ((ret = allocate_method_table(method))) 1473 goto error2; 1474 } else { 1475 method = &(*class)->method_table[mgmt_class]; 1476 if (!*method) { 1477 /* Allocate method table for this management class */ 1478 if ((ret = allocate_method_table(method))) 1479 goto error1; 1480 } 1481 } 1482 1483 /* Now, make sure methods are not already in use */ 1484 if (method_in_use(method, mad_reg_req)) 1485 goto error3; 1486 1487 /* Finally, add in methods being registered */ 1488 for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS) 1489 (*method)->agent[i] = agent_priv; 1490 1491 return 0; 1492 1493error3: 1494 /* Remove any methods for this mad agent */ 1495 remove_methods_mad_agent(*method, agent_priv); 1496 /* Now, check to see if there are any methods in use */ 1497 if (!check_method_table(*method)) { 1498 /* If not, release management method table */ 1499 kfree(*method); 1500 *method = NULL; 1501 } 1502 ret = -EINVAL; 1503 goto error1; 1504error2: 1505 kfree(*class); 1506 *class = NULL; 1507error1: 1508 return ret; 1509} 1510 1511static int add_oui_reg_req(struct ib_mad_reg_req *mad_reg_req, 1512 struct ib_mad_agent_private *agent_priv) 1513{ 1514 struct ib_mad_port_private *port_priv; 1515 struct ib_mad_mgmt_vendor_class_table **vendor_table; 1516 struct ib_mad_mgmt_vendor_class_table *vendor = NULL; 1517 struct ib_mad_mgmt_vendor_class *vendor_class = NULL; 1518 struct ib_mad_mgmt_method_table **method; 1519 int i, ret = -ENOMEM; 1520 u8 vclass; 1521 1522 /* "New" vendor (with OUI) class */ 1523 vclass = vendor_class_index(mad_reg_req->mgmt_class); 1524 port_priv = agent_priv->qp_info->port_priv; 1525 vendor_table = &port_priv->version[ 1526 mad_reg_req->mgmt_class_version].vendor; 1527 if (!*vendor_table) { 1528 /* Allocate mgmt vendor class table for "new" class version */ 1529 vendor = kzalloc(sizeof *vendor, GFP_ATOMIC); 1530 if (!vendor) { 1531 dev_err(&agent_priv->agent.device->dev, 1532 "No memory for ib_mad_mgmt_vendor_class_table\n"); 1533 goto error1; 1534 } 1535 1536 *vendor_table = vendor; 1537 } 1538 if (!(*vendor_table)->vendor_class[vclass]) { 1539 /* Allocate table for this management vendor class */ 1540 vendor_class = kzalloc(sizeof *vendor_class, GFP_ATOMIC); 1541 if (!vendor_class) { 1542 dev_err(&agent_priv->agent.device->dev, 1543 "No memory for ib_mad_mgmt_vendor_class\n"); 1544 goto error2; 1545 } 1546 1547 (*vendor_table)->vendor_class[vclass] = vendor_class; 1548 } 1549 for (i = 0; i < MAX_MGMT_OUI; i++) { 1550 /* Is there matching OUI for this vendor class ? */ 1551 if (!memcmp((*vendor_table)->vendor_class[vclass]->oui[i], 1552 mad_reg_req->oui, 3)) { 1553 method = &(*vendor_table)->vendor_class[ 1554 vclass]->method_table[i]; 1555 BUG_ON(!*method); 1556 goto check_in_use; 1557 } 1558 } 1559 for (i = 0; i < MAX_MGMT_OUI; i++) { 1560 /* OUI slot available ? */ 1561 if (!is_vendor_oui((*vendor_table)->vendor_class[ 1562 vclass]->oui[i])) { 1563 method = &(*vendor_table)->vendor_class[ 1564 vclass]->method_table[i]; 1565 BUG_ON(*method); 1566 /* Allocate method table for this OUI */ 1567 if ((ret = allocate_method_table(method))) 1568 goto error3; 1569 memcpy((*vendor_table)->vendor_class[vclass]->oui[i], 1570 mad_reg_req->oui, 3); 1571 goto check_in_use; 1572 } 1573 } 1574 dev_err(&agent_priv->agent.device->dev, "All OUI slots in use\n"); 1575 goto error3; 1576 1577check_in_use: 1578 /* Now, make sure methods are not already in use */ 1579 if (method_in_use(method, mad_reg_req)) 1580 goto error4; 1581 1582 /* Finally, add in methods being registered */ 1583 for_each_set_bit(i, mad_reg_req->method_mask, IB_MGMT_MAX_METHODS) 1584 (*method)->agent[i] = agent_priv; 1585 1586 return 0; 1587 1588error4: 1589 /* Remove any methods for this mad agent */ 1590 remove_methods_mad_agent(*method, agent_priv); 1591 /* Now, check to see if there are any methods in use */ 1592 if (!check_method_table(*method)) { 1593 /* If not, release management method table */ 1594 kfree(*method); 1595 *method = NULL; 1596 } 1597 ret = -EINVAL; 1598error3: 1599 if (vendor_class) { 1600 (*vendor_table)->vendor_class[vclass] = NULL; 1601 kfree(vendor_class); 1602 } 1603error2: 1604 if (vendor) { 1605 *vendor_table = NULL; 1606 kfree(vendor); 1607 } 1608error1: 1609 return ret; 1610} 1611 1612static void remove_mad_reg_req(struct ib_mad_agent_private *agent_priv) 1613{ 1614 struct ib_mad_port_private *port_priv; 1615 struct ib_mad_mgmt_class_table *class; 1616 struct ib_mad_mgmt_method_table *method; 1617 struct ib_mad_mgmt_vendor_class_table *vendor; 1618 struct ib_mad_mgmt_vendor_class *vendor_class; 1619 int index; 1620 u8 mgmt_class; 1621 1622 /* 1623 * Was MAD registration request supplied 1624 * with original registration ? 1625 */ 1626 if (!agent_priv->reg_req) { 1627 goto out; 1628 } 1629 1630 port_priv = agent_priv->qp_info->port_priv; 1631 mgmt_class = convert_mgmt_class(agent_priv->reg_req->mgmt_class); 1632 class = port_priv->version[ 1633 agent_priv->reg_req->mgmt_class_version].class; 1634 if (!class) 1635 goto vendor_check; 1636 1637 method = class->method_table[mgmt_class]; 1638 if (method) { 1639 /* Remove any methods for this mad agent */ 1640 remove_methods_mad_agent(method, agent_priv); 1641 /* Now, check to see if there are any methods still in use */ 1642 if (!check_method_table(method)) { 1643 /* If not, release management method table */ 1644 kfree(method); 1645 class->method_table[mgmt_class] = NULL; 1646 /* Any management classes left ? */ 1647 if (!check_class_table(class)) { 1648 /* If not, release management class table */ 1649 kfree(class); 1650 port_priv->version[ 1651 agent_priv->reg_req-> 1652 mgmt_class_version].class = NULL; 1653 } 1654 } 1655 } 1656 1657vendor_check: 1658 if (!is_vendor_class(mgmt_class)) 1659 goto out; 1660 1661 /* normalize mgmt_class to vendor range 2 */ 1662 mgmt_class = vendor_class_index(agent_priv->reg_req->mgmt_class); 1663 vendor = port_priv->version[ 1664 agent_priv->reg_req->mgmt_class_version].vendor; 1665 1666 if (!vendor) 1667 goto out; 1668 1669 vendor_class = vendor->vendor_class[mgmt_class]; 1670 if (vendor_class) { 1671 index = find_vendor_oui(vendor_class, agent_priv->reg_req->oui); 1672 if (index < 0) 1673 goto out; 1674 method = vendor_class->method_table[index]; 1675 if (method) { 1676 /* Remove any methods for this mad agent */ 1677 remove_methods_mad_agent(method, agent_priv); 1678 /* 1679 * Now, check to see if there are 1680 * any methods still in use 1681 */ 1682 if (!check_method_table(method)) { 1683 /* If not, release management method table */ 1684 kfree(method); 1685 vendor_class->method_table[index] = NULL; 1686 memset(vendor_class->oui[index], 0, 3); 1687 /* Any OUIs left ? */ 1688 if (!check_vendor_class(vendor_class)) { 1689 /* If not, release vendor class table */ 1690 kfree(vendor_class); 1691 vendor->vendor_class[mgmt_class] = NULL; 1692 /* Any other vendor classes left ? */ 1693 if (!check_vendor_table(vendor)) { 1694 kfree(vendor); 1695 port_priv->version[ 1696 agent_priv->reg_req-> 1697 mgmt_class_version]. 1698 vendor = NULL; 1699 } 1700 } 1701 } 1702 } 1703 } 1704 1705out: 1706 return; 1707} 1708 1709static struct ib_mad_agent_private * 1710find_mad_agent(struct ib_mad_port_private *port_priv, 1711 const struct ib_mad_hdr *mad_hdr) 1712{ 1713 struct ib_mad_agent_private *mad_agent = NULL; 1714 unsigned long flags; 1715 1716 spin_lock_irqsave(&port_priv->reg_lock, flags); 1717 if (ib_response_mad(mad_hdr)) { 1718 u32 hi_tid; 1719 struct ib_mad_agent_private *entry; 1720 1721 /* 1722 * Routing is based on high 32 bits of transaction ID 1723 * of MAD. 1724 */ 1725 hi_tid = be64_to_cpu(mad_hdr->tid) >> 32; 1726 list_for_each_entry(entry, &port_priv->agent_list, agent_list) { 1727 if (entry->agent.hi_tid == hi_tid) { 1728 mad_agent = entry; 1729 break; 1730 } 1731 } 1732 } else { 1733 struct ib_mad_mgmt_class_table *class; 1734 struct ib_mad_mgmt_method_table *method; 1735 struct ib_mad_mgmt_vendor_class_table *vendor; 1736 struct ib_mad_mgmt_vendor_class *vendor_class; 1737 const struct ib_vendor_mad *vendor_mad; 1738 int index; 1739 1740 /* 1741 * Routing is based on version, class, and method 1742 * For "newer" vendor MADs, also based on OUI 1743 */ 1744 if (mad_hdr->class_version >= MAX_MGMT_VERSION) 1745 goto out; 1746 if (!is_vendor_class(mad_hdr->mgmt_class)) { 1747 class = port_priv->version[ 1748 mad_hdr->class_version].class; 1749 if (!class) 1750 goto out; 1751 if (convert_mgmt_class(mad_hdr->mgmt_class) >= 1752 IB_MGMT_MAX_METHODS) 1753 goto out; 1754 method = class->method_table[convert_mgmt_class( 1755 mad_hdr->mgmt_class)]; 1756 if (method) 1757 mad_agent = method->agent[mad_hdr->method & 1758 ~IB_MGMT_METHOD_RESP]; 1759 } else { 1760 vendor = port_priv->version[ 1761 mad_hdr->class_version].vendor; 1762 if (!vendor) 1763 goto out; 1764 vendor_class = vendor->vendor_class[vendor_class_index( 1765 mad_hdr->mgmt_class)]; 1766 if (!vendor_class) 1767 goto out; 1768 /* Find matching OUI */ 1769 vendor_mad = (const struct ib_vendor_mad *)mad_hdr; 1770 index = find_vendor_oui(vendor_class, vendor_mad->oui); 1771 if (index == -1) 1772 goto out; 1773 method = vendor_class->method_table[index]; 1774 if (method) { 1775 mad_agent = method->agent[mad_hdr->method & 1776 ~IB_MGMT_METHOD_RESP]; 1777 } 1778 } 1779 } 1780 1781 if (mad_agent) { 1782 if (mad_agent->agent.recv_handler) 1783 atomic_inc(&mad_agent->refcount); 1784 else { 1785 dev_notice(&port_priv->device->dev, 1786 "No receive handler for client %p on port %d\n", 1787 &mad_agent->agent, port_priv->port_num); 1788 mad_agent = NULL; 1789 } 1790 } 1791out: 1792 spin_unlock_irqrestore(&port_priv->reg_lock, flags); 1793 1794 return mad_agent; 1795} 1796 1797static int validate_mad(const struct ib_mad_hdr *mad_hdr, 1798 const struct ib_mad_qp_info *qp_info, 1799 bool opa) 1800{ 1801 int valid = 0; 1802 u32 qp_num = qp_info->qp->qp_num; 1803 1804 /* Make sure MAD base version is understood */ 1805 if (mad_hdr->base_version != IB_MGMT_BASE_VERSION && 1806 (!opa || mad_hdr->base_version != OPA_MGMT_BASE_VERSION)) { 1807 pr_err("MAD received with unsupported base version %d %s\n", 1808 mad_hdr->base_version, opa ? "(opa)" : ""); 1809 goto out; 1810 } 1811 1812 /* Filter SMI packets sent to other than QP0 */ 1813 if ((mad_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_LID_ROUTED) || 1814 (mad_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)) { 1815 if (qp_num == 0) 1816 valid = 1; 1817 } else { 1818 /* CM attributes other than ClassPortInfo only use Send method */ 1819 if ((mad_hdr->mgmt_class == IB_MGMT_CLASS_CM) && 1820 (mad_hdr->attr_id != IB_MGMT_CLASSPORTINFO_ATTR_ID) && 1821 (mad_hdr->method != IB_MGMT_METHOD_SEND)) 1822 goto out; 1823 /* Filter GSI packets sent to QP0 */ 1824 if (qp_num != 0) 1825 valid = 1; 1826 } 1827 1828out: 1829 return valid; 1830} 1831 1832static int is_rmpp_data_mad(const struct ib_mad_agent_private *mad_agent_priv, 1833 const struct ib_mad_hdr *mad_hdr) 1834{ 1835 const struct ib_rmpp_mad *rmpp_mad; 1836 1837 rmpp_mad = (const struct ib_rmpp_mad *)mad_hdr; 1838 return !mad_agent_priv->agent.rmpp_version || 1839 !ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent) || 1840 !(ib_get_rmpp_flags(&rmpp_mad->rmpp_hdr) & 1841 IB_MGMT_RMPP_FLAG_ACTIVE) || 1842 (rmpp_mad->rmpp_hdr.rmpp_type == IB_MGMT_RMPP_TYPE_DATA); 1843} 1844 1845static inline int rcv_has_same_class(const struct ib_mad_send_wr_private *wr, 1846 const struct ib_mad_recv_wc *rwc) 1847{ 1848 return ((struct ib_mad_hdr *)(wr->send_buf.mad))->mgmt_class == 1849 rwc->recv_buf.mad->mad_hdr.mgmt_class; 1850} 1851 1852static inline int rcv_has_same_gid(const struct ib_mad_agent_private *mad_agent_priv, 1853 const struct ib_mad_send_wr_private *wr, 1854 const struct ib_mad_recv_wc *rwc ) 1855{ 1856 struct ib_ah_attr attr; 1857 u8 send_resp, rcv_resp; 1858 union ib_gid sgid; 1859 struct ib_device *device = mad_agent_priv->agent.device; 1860 u8 port_num = mad_agent_priv->agent.port_num; 1861 u8 lmc; 1862 1863 send_resp = ib_response_mad((struct ib_mad_hdr *)wr->send_buf.mad); 1864 rcv_resp = ib_response_mad(&rwc->recv_buf.mad->mad_hdr); 1865 1866 if (send_resp == rcv_resp) 1867 /* both requests, or both responses. GIDs different */ 1868 return 0; 1869 1870 if (ib_query_ah(wr->send_buf.ah, &attr)) 1871 /* Assume not equal, to avoid false positives. */ 1872 return 0; 1873 1874 if (!!(attr.ah_flags & IB_AH_GRH) != 1875 !!(rwc->wc->wc_flags & IB_WC_GRH)) 1876 /* one has GID, other does not. Assume different */ 1877 return 0; 1878 1879 if (!send_resp && rcv_resp) { 1880 /* is request/response. */ 1881 if (!(attr.ah_flags & IB_AH_GRH)) { 1882 if (ib_get_cached_lmc(device, port_num, &lmc)) 1883 return 0; 1884 return (!lmc || !((attr.src_path_bits ^ 1885 rwc->wc->dlid_path_bits) & 1886 ((1 << lmc) - 1))); 1887 } else { 1888 if (ib_get_cached_gid(device, port_num, 1889 attr.grh.sgid_index, &sgid, NULL)) 1890 return 0; 1891 return !memcmp(sgid.raw, rwc->recv_buf.grh->dgid.raw, 1892 16); 1893 } 1894 } 1895 1896 if (!(attr.ah_flags & IB_AH_GRH)) 1897 return attr.dlid == rwc->wc->slid; 1898 else 1899 return !memcmp(attr.grh.dgid.raw, rwc->recv_buf.grh->sgid.raw, 1900 16); 1901} 1902 1903static inline int is_direct(u8 class) 1904{ 1905 return (class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE); 1906} 1907 1908struct ib_mad_send_wr_private* 1909ib_find_send_mad(const struct ib_mad_agent_private *mad_agent_priv, 1910 const struct ib_mad_recv_wc *wc) 1911{ 1912 struct ib_mad_send_wr_private *wr; 1913 const struct ib_mad_hdr *mad_hdr; 1914 1915 mad_hdr = &wc->recv_buf.mad->mad_hdr; 1916 1917 list_for_each_entry(wr, &mad_agent_priv->wait_list, agent_list) { 1918 if ((wr->tid == mad_hdr->tid) && 1919 rcv_has_same_class(wr, wc) && 1920 /* 1921 * Don't check GID for direct routed MADs. 1922 * These might have permissive LIDs. 1923 */ 1924 (is_direct(mad_hdr->mgmt_class) || 1925 rcv_has_same_gid(mad_agent_priv, wr, wc))) 1926 return (wr->status == IB_WC_SUCCESS) ? wr : NULL; 1927 } 1928 1929 /* 1930 * It's possible to receive the response before we've 1931 * been notified that the send has completed 1932 */ 1933 list_for_each_entry(wr, &mad_agent_priv->send_list, agent_list) { 1934 if (is_rmpp_data_mad(mad_agent_priv, wr->send_buf.mad) && 1935 wr->tid == mad_hdr->tid && 1936 wr->timeout && 1937 rcv_has_same_class(wr, wc) && 1938 /* 1939 * Don't check GID for direct routed MADs. 1940 * These might have permissive LIDs. 1941 */ 1942 (is_direct(mad_hdr->mgmt_class) || 1943 rcv_has_same_gid(mad_agent_priv, wr, wc))) 1944 /* Verify request has not been canceled */ 1945 return (wr->status == IB_WC_SUCCESS) ? wr : NULL; 1946 } 1947 return NULL; 1948} 1949 1950void ib_mark_mad_done(struct ib_mad_send_wr_private *mad_send_wr) 1951{ 1952 mad_send_wr->timeout = 0; 1953 if (mad_send_wr->refcount == 1) 1954 list_move_tail(&mad_send_wr->agent_list, 1955 &mad_send_wr->mad_agent_priv->done_list); 1956} 1957 1958static void ib_mad_complete_recv(struct ib_mad_agent_private *mad_agent_priv, 1959 struct ib_mad_recv_wc *mad_recv_wc) 1960{ 1961 struct ib_mad_send_wr_private *mad_send_wr; 1962 struct ib_mad_send_wc mad_send_wc; 1963 unsigned long flags; 1964 1965 INIT_LIST_HEAD(&mad_recv_wc->rmpp_list); 1966 list_add(&mad_recv_wc->recv_buf.list, &mad_recv_wc->rmpp_list); 1967 if (ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent)) { 1968 mad_recv_wc = ib_process_rmpp_recv_wc(mad_agent_priv, 1969 mad_recv_wc); 1970 if (!mad_recv_wc) { 1971 deref_mad_agent(mad_agent_priv); 1972 return; 1973 } 1974 } 1975 1976 /* Complete corresponding request */ 1977 if (ib_response_mad(&mad_recv_wc->recv_buf.mad->mad_hdr)) { 1978 spin_lock_irqsave(&mad_agent_priv->lock, flags); 1979 mad_send_wr = ib_find_send_mad(mad_agent_priv, mad_recv_wc); 1980 if (!mad_send_wr) { 1981 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 1982 if (!ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent) 1983 && ib_is_mad_class_rmpp(mad_recv_wc->recv_buf.mad->mad_hdr.mgmt_class) 1984 && (ib_get_rmpp_flags(&((struct ib_rmpp_mad *)mad_recv_wc->recv_buf.mad)->rmpp_hdr) 1985 & IB_MGMT_RMPP_FLAG_ACTIVE)) { 1986 /* user rmpp is in effect 1987 * and this is an active RMPP MAD 1988 */ 1989 mad_agent_priv->agent.recv_handler( 1990 &mad_agent_priv->agent, NULL, 1991 mad_recv_wc); 1992 atomic_dec(&mad_agent_priv->refcount); 1993 } else { 1994 /* not user rmpp, revert to normal behavior and 1995 * drop the mad */ 1996 ib_free_recv_mad(mad_recv_wc); 1997 deref_mad_agent(mad_agent_priv); 1998 return; 1999 } 2000 } else { 2001 ib_mark_mad_done(mad_send_wr); 2002 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2003 2004 /* Defined behavior is to complete response before request */ 2005 mad_agent_priv->agent.recv_handler( 2006 &mad_agent_priv->agent, 2007 &mad_send_wr->send_buf, 2008 mad_recv_wc); 2009 atomic_dec(&mad_agent_priv->refcount); 2010 2011 mad_send_wc.status = IB_WC_SUCCESS; 2012 mad_send_wc.vendor_err = 0; 2013 mad_send_wc.send_buf = &mad_send_wr->send_buf; 2014 ib_mad_complete_send_wr(mad_send_wr, &mad_send_wc); 2015 } 2016 } else { 2017 mad_agent_priv->agent.recv_handler(&mad_agent_priv->agent, NULL, 2018 mad_recv_wc); 2019 deref_mad_agent(mad_agent_priv); 2020 } 2021} 2022 2023static enum smi_action handle_ib_smi(const struct ib_mad_port_private *port_priv, 2024 const struct ib_mad_qp_info *qp_info, 2025 const struct ib_wc *wc, 2026 int port_num, 2027 struct ib_mad_private *recv, 2028 struct ib_mad_private *response) 2029{ 2030 enum smi_forward_action retsmi; 2031 struct ib_smp *smp = (struct ib_smp *)recv->mad; 2032 2033 if (smi_handle_dr_smp_recv(smp, 2034 rdma_cap_ib_switch(port_priv->device), 2035 port_num, 2036 port_priv->device->phys_port_cnt) == 2037 IB_SMI_DISCARD) 2038 return IB_SMI_DISCARD; 2039 2040 retsmi = smi_check_forward_dr_smp(smp); 2041 if (retsmi == IB_SMI_LOCAL) 2042 return IB_SMI_HANDLE; 2043 2044 if (retsmi == IB_SMI_SEND) { /* don't forward */ 2045 if (smi_handle_dr_smp_send(smp, 2046 rdma_cap_ib_switch(port_priv->device), 2047 port_num) == IB_SMI_DISCARD) 2048 return IB_SMI_DISCARD; 2049 2050 if (smi_check_local_smp(smp, port_priv->device) == IB_SMI_DISCARD) 2051 return IB_SMI_DISCARD; 2052 } else if (rdma_cap_ib_switch(port_priv->device)) { 2053 /* forward case for switches */ 2054 memcpy(response, recv, mad_priv_size(response)); 2055 response->header.recv_wc.wc = &response->header.wc; 2056 response->header.recv_wc.recv_buf.mad = (struct ib_mad *)response->mad; 2057 response->header.recv_wc.recv_buf.grh = &response->grh; 2058 2059 agent_send_response((const struct ib_mad_hdr *)response->mad, 2060 &response->grh, wc, 2061 port_priv->device, 2062 smi_get_fwd_port(smp), 2063 qp_info->qp->qp_num, 2064 response->mad_size, 2065 false); 2066 2067 return IB_SMI_DISCARD; 2068 } 2069 return IB_SMI_HANDLE; 2070} 2071 2072static bool generate_unmatched_resp(const struct ib_mad_private *recv, 2073 struct ib_mad_private *response, 2074 size_t *resp_len, bool opa) 2075{ 2076 const struct ib_mad_hdr *recv_hdr = (const struct ib_mad_hdr *)recv->mad; 2077 struct ib_mad_hdr *resp_hdr = (struct ib_mad_hdr *)response->mad; 2078 2079 if (recv_hdr->method == IB_MGMT_METHOD_GET || 2080 recv_hdr->method == IB_MGMT_METHOD_SET) { 2081 memcpy(response, recv, mad_priv_size(response)); 2082 response->header.recv_wc.wc = &response->header.wc; 2083 response->header.recv_wc.recv_buf.mad = (struct ib_mad *)response->mad; 2084 response->header.recv_wc.recv_buf.grh = &response->grh; 2085 resp_hdr->method = IB_MGMT_METHOD_GET_RESP; 2086 resp_hdr->status = cpu_to_be16(IB_MGMT_MAD_STATUS_UNSUPPORTED_METHOD_ATTRIB); 2087 if (recv_hdr->mgmt_class == IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) 2088 resp_hdr->status |= IB_SMP_DIRECTION; 2089 2090 if (opa && recv_hdr->base_version == OPA_MGMT_BASE_VERSION) { 2091 if (recv_hdr->mgmt_class == 2092 IB_MGMT_CLASS_SUBN_LID_ROUTED || 2093 recv_hdr->mgmt_class == 2094 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) 2095 *resp_len = opa_get_smp_header_size( 2096 (const struct opa_smp *)recv->mad); 2097 else 2098 *resp_len = sizeof(struct ib_mad_hdr); 2099 } 2100 2101 return true; 2102 } else { 2103 return false; 2104 } 2105} 2106 2107static enum smi_action 2108handle_opa_smi(struct ib_mad_port_private *port_priv, 2109 struct ib_mad_qp_info *qp_info, 2110 struct ib_wc *wc, 2111 int port_num, 2112 struct ib_mad_private *recv, 2113 struct ib_mad_private *response) 2114{ 2115 enum smi_forward_action retsmi; 2116 struct opa_smp *smp = (struct opa_smp *)recv->mad; 2117 2118 if (opa_smi_handle_dr_smp_recv(smp, 2119 rdma_cap_ib_switch(port_priv->device), 2120 port_num, 2121 port_priv->device->phys_port_cnt) == 2122 IB_SMI_DISCARD) 2123 return IB_SMI_DISCARD; 2124 2125 retsmi = opa_smi_check_forward_dr_smp(smp); 2126 if (retsmi == IB_SMI_LOCAL) 2127 return IB_SMI_HANDLE; 2128 2129 if (retsmi == IB_SMI_SEND) { /* don't forward */ 2130 if (opa_smi_handle_dr_smp_send(smp, 2131 rdma_cap_ib_switch(port_priv->device), 2132 port_num) == IB_SMI_DISCARD) 2133 return IB_SMI_DISCARD; 2134 2135 if (opa_smi_check_local_smp(smp, port_priv->device) == 2136 IB_SMI_DISCARD) 2137 return IB_SMI_DISCARD; 2138 2139 } else if (rdma_cap_ib_switch(port_priv->device)) { 2140 /* forward case for switches */ 2141 memcpy(response, recv, mad_priv_size(response)); 2142 response->header.recv_wc.wc = &response->header.wc; 2143 response->header.recv_wc.recv_buf.opa_mad = 2144 (struct opa_mad *)response->mad; 2145 response->header.recv_wc.recv_buf.grh = &response->grh; 2146 2147 agent_send_response((const struct ib_mad_hdr *)response->mad, 2148 &response->grh, wc, 2149 port_priv->device, 2150 opa_smi_get_fwd_port(smp), 2151 qp_info->qp->qp_num, 2152 recv->header.wc.byte_len, 2153 true); 2154 2155 return IB_SMI_DISCARD; 2156 } 2157 2158 return IB_SMI_HANDLE; 2159} 2160 2161static enum smi_action 2162handle_smi(struct ib_mad_port_private *port_priv, 2163 struct ib_mad_qp_info *qp_info, 2164 struct ib_wc *wc, 2165 int port_num, 2166 struct ib_mad_private *recv, 2167 struct ib_mad_private *response, 2168 bool opa) 2169{ 2170 struct ib_mad_hdr *mad_hdr = (struct ib_mad_hdr *)recv->mad; 2171 2172 if (opa && mad_hdr->base_version == OPA_MGMT_BASE_VERSION && 2173 mad_hdr->class_version == OPA_SMI_CLASS_VERSION) 2174 return handle_opa_smi(port_priv, qp_info, wc, port_num, recv, 2175 response); 2176 2177 return handle_ib_smi(port_priv, qp_info, wc, port_num, recv, response); 2178} 2179 2180static void ib_mad_recv_done(struct ib_cq *cq, struct ib_wc *wc) 2181{ 2182 struct ib_mad_port_private *port_priv = cq->cq_context; 2183 struct ib_mad_list_head *mad_list = 2184 container_of(wc->wr_cqe, struct ib_mad_list_head, cqe); 2185 struct ib_mad_qp_info *qp_info; 2186 struct ib_mad_private_header *mad_priv_hdr; 2187 struct ib_mad_private *recv, *response = NULL; 2188 struct ib_mad_agent_private *mad_agent; 2189 int port_num; 2190 int ret = IB_MAD_RESULT_SUCCESS; 2191 size_t mad_size; 2192 u16 resp_mad_pkey_index = 0; 2193 bool opa; 2194 2195 if (list_empty_careful(&port_priv->port_list)) 2196 return; 2197 2198 if (wc->status != IB_WC_SUCCESS) { 2199 /* 2200 * Receive errors indicate that the QP has entered the error 2201 * state - error handling/shutdown code will cleanup 2202 */ 2203 return; 2204 } 2205 2206 qp_info = mad_list->mad_queue->qp_info; 2207 dequeue_mad(mad_list); 2208 2209 opa = rdma_cap_opa_mad(qp_info->port_priv->device, 2210 qp_info->port_priv->port_num); 2211 2212 mad_priv_hdr = container_of(mad_list, struct ib_mad_private_header, 2213 mad_list); 2214 recv = container_of(mad_priv_hdr, struct ib_mad_private, header); 2215 ib_dma_unmap_single(port_priv->device, 2216 recv->header.mapping, 2217 mad_priv_dma_size(recv), 2218 DMA_FROM_DEVICE); 2219 2220 /* Setup MAD receive work completion from "normal" work completion */ 2221 recv->header.wc = *wc; 2222 recv->header.recv_wc.wc = &recv->header.wc; 2223 2224 if (opa && ((struct ib_mad_hdr *)(recv->mad))->base_version == OPA_MGMT_BASE_VERSION) { 2225 recv->header.recv_wc.mad_len = wc->byte_len - sizeof(struct ib_grh); 2226 recv->header.recv_wc.mad_seg_size = sizeof(struct opa_mad); 2227 } else { 2228 recv->header.recv_wc.mad_len = sizeof(struct ib_mad); 2229 recv->header.recv_wc.mad_seg_size = sizeof(struct ib_mad); 2230 } 2231 2232 recv->header.recv_wc.recv_buf.mad = (struct ib_mad *)recv->mad; 2233 recv->header.recv_wc.recv_buf.grh = &recv->grh; 2234 2235 if (atomic_read(&qp_info->snoop_count)) 2236 snoop_recv(qp_info, &recv->header.recv_wc, IB_MAD_SNOOP_RECVS); 2237 2238 /* Validate MAD */ 2239 if (!validate_mad((const struct ib_mad_hdr *)recv->mad, qp_info, opa)) 2240 goto out; 2241 2242 mad_size = recv->mad_size; 2243 response = alloc_mad_private(mad_size, GFP_KERNEL); 2244 if (!response) { 2245 dev_err(&port_priv->device->dev, 2246 "%s: no memory for response buffer\n", __func__); 2247 goto out; 2248 } 2249 2250 if (rdma_cap_ib_switch(port_priv->device)) 2251 port_num = wc->port_num; 2252 else 2253 port_num = port_priv->port_num; 2254 2255 if (((struct ib_mad_hdr *)recv->mad)->mgmt_class == 2256 IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) { 2257 if (handle_smi(port_priv, qp_info, wc, port_num, recv, 2258 response, opa) 2259 == IB_SMI_DISCARD) 2260 goto out; 2261 } 2262 2263 /* Give driver "right of first refusal" on incoming MAD */ 2264 if (port_priv->device->process_mad) { 2265 ret = port_priv->device->process_mad(port_priv->device, 0, 2266 port_priv->port_num, 2267 wc, &recv->grh, 2268 (const struct ib_mad_hdr *)recv->mad, 2269 recv->mad_size, 2270 (struct ib_mad_hdr *)response->mad, 2271 &mad_size, &resp_mad_pkey_index); 2272 2273 if (opa) 2274 wc->pkey_index = resp_mad_pkey_index; 2275 2276 if (ret & IB_MAD_RESULT_SUCCESS) { 2277 if (ret & IB_MAD_RESULT_CONSUMED) 2278 goto out; 2279 if (ret & IB_MAD_RESULT_REPLY) { 2280 agent_send_response((const struct ib_mad_hdr *)response->mad, 2281 &recv->grh, wc, 2282 port_priv->device, 2283 port_num, 2284 qp_info->qp->qp_num, 2285 mad_size, opa); 2286 goto out; 2287 } 2288 } 2289 } 2290 2291 mad_agent = find_mad_agent(port_priv, (const struct ib_mad_hdr *)recv->mad); 2292 if (mad_agent) { 2293 ib_mad_complete_recv(mad_agent, &recv->header.recv_wc); 2294 /* 2295 * recv is freed up in error cases in ib_mad_complete_recv 2296 * or via recv_handler in ib_mad_complete_recv() 2297 */ 2298 recv = NULL; 2299 } else if ((ret & IB_MAD_RESULT_SUCCESS) && 2300 generate_unmatched_resp(recv, response, &mad_size, opa)) { 2301 agent_send_response((const struct ib_mad_hdr *)response->mad, &recv->grh, wc, 2302 port_priv->device, port_num, 2303 qp_info->qp->qp_num, mad_size, opa); 2304 } 2305 2306out: 2307 /* Post another receive request for this QP */ 2308 if (response) { 2309 ib_mad_post_receive_mads(qp_info, response); 2310 kfree(recv); 2311 } else 2312 ib_mad_post_receive_mads(qp_info, recv); 2313} 2314 2315static void adjust_timeout(struct ib_mad_agent_private *mad_agent_priv) 2316{ 2317 struct ib_mad_send_wr_private *mad_send_wr; 2318 unsigned long delay; 2319 2320 if (list_empty(&mad_agent_priv->wait_list)) { 2321 cancel_delayed_work(&mad_agent_priv->timed_work); 2322 } else { 2323 mad_send_wr = list_entry(mad_agent_priv->wait_list.next, 2324 struct ib_mad_send_wr_private, 2325 agent_list); 2326 2327 if (time_after(mad_agent_priv->timeout, 2328 mad_send_wr->timeout)) { 2329 mad_agent_priv->timeout = mad_send_wr->timeout; 2330 delay = mad_send_wr->timeout - jiffies; 2331 if ((long)delay <= 0) 2332 delay = 1; 2333 mod_delayed_work(mad_agent_priv->qp_info->port_priv->wq, 2334 &mad_agent_priv->timed_work, delay); 2335 } 2336 } 2337} 2338 2339static void wait_for_response(struct ib_mad_send_wr_private *mad_send_wr) 2340{ 2341 struct ib_mad_agent_private *mad_agent_priv; 2342 struct ib_mad_send_wr_private *temp_mad_send_wr; 2343 struct list_head *list_item; 2344 unsigned long delay; 2345 2346 mad_agent_priv = mad_send_wr->mad_agent_priv; 2347 list_del(&mad_send_wr->agent_list); 2348 2349 delay = mad_send_wr->timeout; 2350 mad_send_wr->timeout += jiffies; 2351 2352 if (delay) { 2353 list_for_each_prev(list_item, &mad_agent_priv->wait_list) { 2354 temp_mad_send_wr = list_entry(list_item, 2355 struct ib_mad_send_wr_private, 2356 agent_list); 2357 if (time_after(mad_send_wr->timeout, 2358 temp_mad_send_wr->timeout)) 2359 break; 2360 } 2361 } 2362 else 2363 list_item = &mad_agent_priv->wait_list; 2364 list_add(&mad_send_wr->agent_list, list_item); 2365 2366 /* Reschedule a work item if we have a shorter timeout */ 2367 if (mad_agent_priv->wait_list.next == &mad_send_wr->agent_list) 2368 mod_delayed_work(mad_agent_priv->qp_info->port_priv->wq, 2369 &mad_agent_priv->timed_work, delay); 2370} 2371 2372void ib_reset_mad_timeout(struct ib_mad_send_wr_private *mad_send_wr, 2373 int timeout_ms) 2374{ 2375 mad_send_wr->timeout = msecs_to_jiffies(timeout_ms); 2376 wait_for_response(mad_send_wr); 2377} 2378 2379/* 2380 * Process a send work completion 2381 */ 2382void ib_mad_complete_send_wr(struct ib_mad_send_wr_private *mad_send_wr, 2383 struct ib_mad_send_wc *mad_send_wc) 2384{ 2385 struct ib_mad_agent_private *mad_agent_priv; 2386 unsigned long flags; 2387 int ret; 2388 2389 mad_agent_priv = mad_send_wr->mad_agent_priv; 2390 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2391 if (ib_mad_kernel_rmpp_agent(&mad_agent_priv->agent)) { 2392 ret = ib_process_rmpp_send_wc(mad_send_wr, mad_send_wc); 2393 if (ret == IB_RMPP_RESULT_CONSUMED) 2394 goto done; 2395 } else 2396 ret = IB_RMPP_RESULT_UNHANDLED; 2397 2398 if (mad_send_wc->status != IB_WC_SUCCESS && 2399 mad_send_wr->status == IB_WC_SUCCESS) { 2400 mad_send_wr->status = mad_send_wc->status; 2401 mad_send_wr->refcount -= (mad_send_wr->timeout > 0); 2402 } 2403 2404 if (--mad_send_wr->refcount > 0) { 2405 if (mad_send_wr->refcount == 1 && mad_send_wr->timeout && 2406 mad_send_wr->status == IB_WC_SUCCESS) { 2407 wait_for_response(mad_send_wr); 2408 } 2409 goto done; 2410 } 2411 2412 /* Remove send from MAD agent and notify client of completion */ 2413 list_del(&mad_send_wr->agent_list); 2414 adjust_timeout(mad_agent_priv); 2415 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2416 2417 if (mad_send_wr->status != IB_WC_SUCCESS ) 2418 mad_send_wc->status = mad_send_wr->status; 2419 if (ret == IB_RMPP_RESULT_INTERNAL) 2420 ib_rmpp_send_handler(mad_send_wc); 2421 else 2422 mad_agent_priv->agent.send_handler(&mad_agent_priv->agent, 2423 mad_send_wc); 2424 2425 /* Release reference on agent taken when sending */ 2426 deref_mad_agent(mad_agent_priv); 2427 return; 2428done: 2429 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2430} 2431 2432static void ib_mad_send_done(struct ib_cq *cq, struct ib_wc *wc) 2433{ 2434 struct ib_mad_port_private *port_priv = cq->cq_context; 2435 struct ib_mad_list_head *mad_list = 2436 container_of(wc->wr_cqe, struct ib_mad_list_head, cqe); 2437 struct ib_mad_send_wr_private *mad_send_wr, *queued_send_wr; 2438 struct ib_mad_qp_info *qp_info; 2439 struct ib_mad_queue *send_queue; 2440 struct ib_send_wr *bad_send_wr; 2441 struct ib_mad_send_wc mad_send_wc; 2442 unsigned long flags; 2443 int ret; 2444 2445 if (list_empty_careful(&port_priv->port_list)) 2446 return; 2447 2448 if (wc->status != IB_WC_SUCCESS) { 2449 if (!ib_mad_send_error(port_priv, wc)) 2450 return; 2451 } 2452 2453 mad_send_wr = container_of(mad_list, struct ib_mad_send_wr_private, 2454 mad_list); 2455 send_queue = mad_list->mad_queue; 2456 qp_info = send_queue->qp_info; 2457 2458retry: 2459 ib_dma_unmap_single(mad_send_wr->send_buf.mad_agent->device, 2460 mad_send_wr->header_mapping, 2461 mad_send_wr->sg_list[0].length, DMA_TO_DEVICE); 2462 ib_dma_unmap_single(mad_send_wr->send_buf.mad_agent->device, 2463 mad_send_wr->payload_mapping, 2464 mad_send_wr->sg_list[1].length, DMA_TO_DEVICE); 2465 queued_send_wr = NULL; 2466 spin_lock_irqsave(&send_queue->lock, flags); 2467 list_del(&mad_list->list); 2468 2469 /* Move queued send to the send queue */ 2470 if (send_queue->count-- > send_queue->max_active) { 2471 mad_list = container_of(qp_info->overflow_list.next, 2472 struct ib_mad_list_head, list); 2473 queued_send_wr = container_of(mad_list, 2474 struct ib_mad_send_wr_private, 2475 mad_list); 2476 list_move_tail(&mad_list->list, &send_queue->list); 2477 } 2478 spin_unlock_irqrestore(&send_queue->lock, flags); 2479 2480 mad_send_wc.send_buf = &mad_send_wr->send_buf; 2481 mad_send_wc.status = wc->status; 2482 mad_send_wc.vendor_err = wc->vendor_err; 2483 if (atomic_read(&qp_info->snoop_count)) 2484 snoop_send(qp_info, &mad_send_wr->send_buf, &mad_send_wc, 2485 IB_MAD_SNOOP_SEND_COMPLETIONS); 2486 ib_mad_complete_send_wr(mad_send_wr, &mad_send_wc); 2487 2488 if (queued_send_wr) { 2489 ret = ib_post_send(qp_info->qp, &queued_send_wr->send_wr.wr, 2490 &bad_send_wr); 2491 if (ret) { 2492 dev_err(&port_priv->device->dev, 2493 "ib_post_send failed: %d\n", ret); 2494 mad_send_wr = queued_send_wr; 2495 wc->status = IB_WC_LOC_QP_OP_ERR; 2496 goto retry; 2497 } 2498 } 2499} 2500 2501static void mark_sends_for_retry(struct ib_mad_qp_info *qp_info) 2502{ 2503 struct ib_mad_send_wr_private *mad_send_wr; 2504 struct ib_mad_list_head *mad_list; 2505 unsigned long flags; 2506 2507 spin_lock_irqsave(&qp_info->send_queue.lock, flags); 2508 list_for_each_entry(mad_list, &qp_info->send_queue.list, list) { 2509 mad_send_wr = container_of(mad_list, 2510 struct ib_mad_send_wr_private, 2511 mad_list); 2512 mad_send_wr->retry = 1; 2513 } 2514 spin_unlock_irqrestore(&qp_info->send_queue.lock, flags); 2515} 2516 2517static bool ib_mad_send_error(struct ib_mad_port_private *port_priv, 2518 struct ib_wc *wc) 2519{ 2520 struct ib_mad_list_head *mad_list = 2521 container_of(wc->wr_cqe, struct ib_mad_list_head, cqe); 2522 struct ib_mad_qp_info *qp_info = mad_list->mad_queue->qp_info; 2523 struct ib_mad_send_wr_private *mad_send_wr; 2524 int ret; 2525 2526 /* 2527 * Send errors will transition the QP to SQE - move 2528 * QP to RTS and repost flushed work requests 2529 */ 2530 mad_send_wr = container_of(mad_list, struct ib_mad_send_wr_private, 2531 mad_list); 2532 if (wc->status == IB_WC_WR_FLUSH_ERR) { 2533 if (mad_send_wr->retry) { 2534 /* Repost send */ 2535 struct ib_send_wr *bad_send_wr; 2536 2537 mad_send_wr->retry = 0; 2538 ret = ib_post_send(qp_info->qp, &mad_send_wr->send_wr.wr, 2539 &bad_send_wr); 2540 if (!ret) 2541 return false; 2542 } 2543 } else { 2544 struct ib_qp_attr *attr; 2545 2546 /* Transition QP to RTS and fail offending send */ 2547 attr = kmalloc(sizeof *attr, GFP_KERNEL); 2548 if (attr) { 2549 attr->qp_state = IB_QPS_RTS; 2550 attr->cur_qp_state = IB_QPS_SQE; 2551 ret = ib_modify_qp(qp_info->qp, attr, 2552 IB_QP_STATE | IB_QP_CUR_STATE); 2553 kfree(attr); 2554 if (ret) 2555 dev_err(&port_priv->device->dev, 2556 "%s - ib_modify_qp to RTS: %d\n", 2557 __func__, ret); 2558 else 2559 mark_sends_for_retry(qp_info); 2560 } 2561 } 2562 2563 return true; 2564} 2565 2566static void cancel_mads(struct ib_mad_agent_private *mad_agent_priv) 2567{ 2568 unsigned long flags; 2569 struct ib_mad_send_wr_private *mad_send_wr, *temp_mad_send_wr; 2570 struct ib_mad_send_wc mad_send_wc; 2571 struct list_head cancel_list; 2572 2573 INIT_LIST_HEAD(&cancel_list); 2574 2575 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2576 list_for_each_entry_safe(mad_send_wr, temp_mad_send_wr, 2577 &mad_agent_priv->send_list, agent_list) { 2578 if (mad_send_wr->status == IB_WC_SUCCESS) { 2579 mad_send_wr->status = IB_WC_WR_FLUSH_ERR; 2580 mad_send_wr->refcount -= (mad_send_wr->timeout > 0); 2581 } 2582 } 2583 2584 /* Empty wait list to prevent receives from finding a request */ 2585 list_splice_init(&mad_agent_priv->wait_list, &cancel_list); 2586 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2587 2588 /* Report all cancelled requests */ 2589 mad_send_wc.status = IB_WC_WR_FLUSH_ERR; 2590 mad_send_wc.vendor_err = 0; 2591 2592 list_for_each_entry_safe(mad_send_wr, temp_mad_send_wr, 2593 &cancel_list, agent_list) { 2594 mad_send_wc.send_buf = &mad_send_wr->send_buf; 2595 list_del(&mad_send_wr->agent_list); 2596 mad_agent_priv->agent.send_handler(&mad_agent_priv->agent, 2597 &mad_send_wc); 2598 atomic_dec(&mad_agent_priv->refcount); 2599 } 2600} 2601 2602static struct ib_mad_send_wr_private* 2603find_send_wr(struct ib_mad_agent_private *mad_agent_priv, 2604 struct ib_mad_send_buf *send_buf) 2605{ 2606 struct ib_mad_send_wr_private *mad_send_wr; 2607 2608 list_for_each_entry(mad_send_wr, &mad_agent_priv->wait_list, 2609 agent_list) { 2610 if (&mad_send_wr->send_buf == send_buf) 2611 return mad_send_wr; 2612 } 2613 2614 list_for_each_entry(mad_send_wr, &mad_agent_priv->send_list, 2615 agent_list) { 2616 if (is_rmpp_data_mad(mad_agent_priv, 2617 mad_send_wr->send_buf.mad) && 2618 &mad_send_wr->send_buf == send_buf) 2619 return mad_send_wr; 2620 } 2621 return NULL; 2622} 2623 2624int ib_modify_mad(struct ib_mad_agent *mad_agent, 2625 struct ib_mad_send_buf *send_buf, u32 timeout_ms) 2626{ 2627 struct ib_mad_agent_private *mad_agent_priv; 2628 struct ib_mad_send_wr_private *mad_send_wr; 2629 unsigned long flags; 2630 int active; 2631 2632 mad_agent_priv = container_of(mad_agent, struct ib_mad_agent_private, 2633 agent); 2634 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2635 mad_send_wr = find_send_wr(mad_agent_priv, send_buf); 2636 if (!mad_send_wr || mad_send_wr->status != IB_WC_SUCCESS) { 2637 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2638 return -EINVAL; 2639 } 2640 2641 active = (!mad_send_wr->timeout || mad_send_wr->refcount > 1); 2642 if (!timeout_ms) { 2643 mad_send_wr->status = IB_WC_WR_FLUSH_ERR; 2644 mad_send_wr->refcount -= (mad_send_wr->timeout > 0); 2645 } 2646 2647 mad_send_wr->send_buf.timeout_ms = timeout_ms; 2648 if (active) 2649 mad_send_wr->timeout = msecs_to_jiffies(timeout_ms); 2650 else 2651 ib_reset_mad_timeout(mad_send_wr, timeout_ms); 2652 2653 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2654 return 0; 2655} 2656EXPORT_SYMBOL(ib_modify_mad); 2657 2658void ib_cancel_mad(struct ib_mad_agent *mad_agent, 2659 struct ib_mad_send_buf *send_buf) 2660{ 2661 ib_modify_mad(mad_agent, send_buf, 0); 2662} 2663EXPORT_SYMBOL(ib_cancel_mad); 2664 2665static void local_completions(struct work_struct *work) 2666{ 2667 struct ib_mad_agent_private *mad_agent_priv; 2668 struct ib_mad_local_private *local; 2669 struct ib_mad_agent_private *recv_mad_agent; 2670 unsigned long flags; 2671 int free_mad; 2672 struct ib_wc wc; 2673 struct ib_mad_send_wc mad_send_wc; 2674 bool opa; 2675 2676 mad_agent_priv = 2677 container_of(work, struct ib_mad_agent_private, local_work); 2678 2679 opa = rdma_cap_opa_mad(mad_agent_priv->qp_info->port_priv->device, 2680 mad_agent_priv->qp_info->port_priv->port_num); 2681 2682 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2683 while (!list_empty(&mad_agent_priv->local_list)) { 2684 local = list_entry(mad_agent_priv->local_list.next, 2685 struct ib_mad_local_private, 2686 completion_list); 2687 list_del(&local->completion_list); 2688 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2689 free_mad = 0; 2690 if (local->mad_priv) { 2691 u8 base_version; 2692 recv_mad_agent = local->recv_mad_agent; 2693 if (!recv_mad_agent) { 2694 dev_err(&mad_agent_priv->agent.device->dev, 2695 "No receive MAD agent for local completion\n"); 2696 free_mad = 1; 2697 goto local_send_completion; 2698 } 2699 2700 /* 2701 * Defined behavior is to complete response 2702 * before request 2703 */ 2704 build_smp_wc(recv_mad_agent->agent.qp, 2705 local->mad_send_wr->send_wr.wr.wr_cqe, 2706 be16_to_cpu(IB_LID_PERMISSIVE), 2707 local->mad_send_wr->send_wr.pkey_index, 2708 recv_mad_agent->agent.port_num, &wc); 2709 2710 local->mad_priv->header.recv_wc.wc = &wc; 2711 2712 base_version = ((struct ib_mad_hdr *)(local->mad_priv->mad))->base_version; 2713 if (opa && base_version == OPA_MGMT_BASE_VERSION) { 2714 local->mad_priv->header.recv_wc.mad_len = local->return_wc_byte_len; 2715 local->mad_priv->header.recv_wc.mad_seg_size = sizeof(struct opa_mad); 2716 } else { 2717 local->mad_priv->header.recv_wc.mad_len = sizeof(struct ib_mad); 2718 local->mad_priv->header.recv_wc.mad_seg_size = sizeof(struct ib_mad); 2719 } 2720 2721 INIT_LIST_HEAD(&local->mad_priv->header.recv_wc.rmpp_list); 2722 list_add(&local->mad_priv->header.recv_wc.recv_buf.list, 2723 &local->mad_priv->header.recv_wc.rmpp_list); 2724 local->mad_priv->header.recv_wc.recv_buf.grh = NULL; 2725 local->mad_priv->header.recv_wc.recv_buf.mad = 2726 (struct ib_mad *)local->mad_priv->mad; 2727 if (atomic_read(&recv_mad_agent->qp_info->snoop_count)) 2728 snoop_recv(recv_mad_agent->qp_info, 2729 &local->mad_priv->header.recv_wc, 2730 IB_MAD_SNOOP_RECVS); 2731 recv_mad_agent->agent.recv_handler( 2732 &recv_mad_agent->agent, 2733 &local->mad_send_wr->send_buf, 2734 &local->mad_priv->header.recv_wc); 2735 spin_lock_irqsave(&recv_mad_agent->lock, flags); 2736 atomic_dec(&recv_mad_agent->refcount); 2737 spin_unlock_irqrestore(&recv_mad_agent->lock, flags); 2738 } 2739 2740local_send_completion: 2741 /* Complete send */ 2742 mad_send_wc.status = IB_WC_SUCCESS; 2743 mad_send_wc.vendor_err = 0; 2744 mad_send_wc.send_buf = &local->mad_send_wr->send_buf; 2745 if (atomic_read(&mad_agent_priv->qp_info->snoop_count)) 2746 snoop_send(mad_agent_priv->qp_info, 2747 &local->mad_send_wr->send_buf, 2748 &mad_send_wc, IB_MAD_SNOOP_SEND_COMPLETIONS); 2749 mad_agent_priv->agent.send_handler(&mad_agent_priv->agent, 2750 &mad_send_wc); 2751 2752 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2753 atomic_dec(&mad_agent_priv->refcount); 2754 if (free_mad) 2755 kfree(local->mad_priv); 2756 kfree(local); 2757 } 2758 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2759} 2760 2761static int retry_send(struct ib_mad_send_wr_private *mad_send_wr) 2762{ 2763 int ret; 2764 2765 if (!mad_send_wr->retries_left) 2766 return -ETIMEDOUT; 2767 2768 mad_send_wr->retries_left--; 2769 mad_send_wr->send_buf.retries++; 2770 2771 mad_send_wr->timeout = msecs_to_jiffies(mad_send_wr->send_buf.timeout_ms); 2772 2773 if (ib_mad_kernel_rmpp_agent(&mad_send_wr->mad_agent_priv->agent)) { 2774 ret = ib_retry_rmpp(mad_send_wr); 2775 switch (ret) { 2776 case IB_RMPP_RESULT_UNHANDLED: 2777 ret = ib_send_mad(mad_send_wr); 2778 break; 2779 case IB_RMPP_RESULT_CONSUMED: 2780 ret = 0; 2781 break; 2782 default: 2783 ret = -ECOMM; 2784 break; 2785 } 2786 } else 2787 ret = ib_send_mad(mad_send_wr); 2788 2789 if (!ret) { 2790 mad_send_wr->refcount++; 2791 list_add_tail(&mad_send_wr->agent_list, 2792 &mad_send_wr->mad_agent_priv->send_list); 2793 } 2794 return ret; 2795} 2796 2797static void timeout_sends(struct work_struct *work) 2798{ 2799 struct ib_mad_agent_private *mad_agent_priv; 2800 struct ib_mad_send_wr_private *mad_send_wr; 2801 struct ib_mad_send_wc mad_send_wc; 2802 unsigned long flags, delay; 2803 2804 mad_agent_priv = container_of(work, struct ib_mad_agent_private, 2805 timed_work.work); 2806 mad_send_wc.vendor_err = 0; 2807 2808 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2809 while (!list_empty(&mad_agent_priv->wait_list)) { 2810 mad_send_wr = list_entry(mad_agent_priv->wait_list.next, 2811 struct ib_mad_send_wr_private, 2812 agent_list); 2813 2814 if (time_after(mad_send_wr->timeout, jiffies)) { 2815 delay = mad_send_wr->timeout - jiffies; 2816 if ((long)delay <= 0) 2817 delay = 1; 2818 queue_delayed_work(mad_agent_priv->qp_info-> 2819 port_priv->wq, 2820 &mad_agent_priv->timed_work, delay); 2821 break; 2822 } 2823 2824 list_del(&mad_send_wr->agent_list); 2825 if (mad_send_wr->status == IB_WC_SUCCESS && 2826 !retry_send(mad_send_wr)) 2827 continue; 2828 2829 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2830 2831 if (mad_send_wr->status == IB_WC_SUCCESS) 2832 mad_send_wc.status = IB_WC_RESP_TIMEOUT_ERR; 2833 else 2834 mad_send_wc.status = mad_send_wr->status; 2835 mad_send_wc.send_buf = &mad_send_wr->send_buf; 2836 mad_agent_priv->agent.send_handler(&mad_agent_priv->agent, 2837 &mad_send_wc); 2838 2839 atomic_dec(&mad_agent_priv->refcount); 2840 spin_lock_irqsave(&mad_agent_priv->lock, flags); 2841 } 2842 spin_unlock_irqrestore(&mad_agent_priv->lock, flags); 2843} 2844 2845/* 2846 * Allocate receive MADs and post receive WRs for them 2847 */ 2848static int ib_mad_post_receive_mads(struct ib_mad_qp_info *qp_info, 2849 struct ib_mad_private *mad) 2850{ 2851 unsigned long flags; 2852 int post, ret; 2853 struct ib_mad_private *mad_priv; 2854 struct ib_sge sg_list; 2855 struct ib_recv_wr recv_wr, *bad_recv_wr; 2856 struct ib_mad_queue *recv_queue = &qp_info->recv_queue; 2857 2858 /* Initialize common scatter list fields */ 2859 sg_list.lkey = qp_info->port_priv->pd->local_dma_lkey; 2860 2861 /* Initialize common receive WR fields */ 2862 recv_wr.next = NULL; 2863 recv_wr.sg_list = &sg_list; 2864 recv_wr.num_sge = 1; 2865 2866 do { 2867 /* Allocate and map receive buffer */ 2868 if (mad) { 2869 mad_priv = mad; 2870 mad = NULL; 2871 } else { 2872 mad_priv = alloc_mad_private(port_mad_size(qp_info->port_priv), 2873 GFP_ATOMIC); 2874 if (!mad_priv) { 2875 dev_err(&qp_info->port_priv->device->dev, 2876 "No memory for receive buffer\n"); 2877 ret = -ENOMEM; 2878 break; 2879 } 2880 } 2881 sg_list.length = mad_priv_dma_size(mad_priv); 2882 sg_list.addr = ib_dma_map_single(qp_info->port_priv->device, 2883 &mad_priv->grh, 2884 mad_priv_dma_size(mad_priv), 2885 DMA_FROM_DEVICE); 2886 if (unlikely(ib_dma_mapping_error(qp_info->port_priv->device, 2887 sg_list.addr))) { 2888 ret = -ENOMEM; 2889 break; 2890 } 2891 mad_priv->header.mapping = sg_list.addr; 2892 mad_priv->header.mad_list.mad_queue = recv_queue; 2893 mad_priv->header.mad_list.cqe.done = ib_mad_recv_done; 2894 recv_wr.wr_cqe = &mad_priv->header.mad_list.cqe; 2895 2896 /* Post receive WR */ 2897 spin_lock_irqsave(&recv_queue->lock, flags); 2898 post = (++recv_queue->count < recv_queue->max_active); 2899 list_add_tail(&mad_priv->header.mad_list.list, &recv_queue->list); 2900 spin_unlock_irqrestore(&recv_queue->lock, flags); 2901 ret = ib_post_recv(qp_info->qp, &recv_wr, &bad_recv_wr); 2902 if (ret) { 2903 spin_lock_irqsave(&recv_queue->lock, flags); 2904 list_del(&mad_priv->header.mad_list.list); 2905 recv_queue->count--; 2906 spin_unlock_irqrestore(&recv_queue->lock, flags); 2907 ib_dma_unmap_single(qp_info->port_priv->device, 2908 mad_priv->header.mapping, 2909 mad_priv_dma_size(mad_priv), 2910 DMA_FROM_DEVICE); 2911 kfree(mad_priv); 2912 dev_err(&qp_info->port_priv->device->dev, 2913 "ib_post_recv failed: %d\n", ret); 2914 break; 2915 } 2916 } while (post); 2917 2918 return ret; 2919} 2920 2921/* 2922 * Return all the posted receive MADs 2923 */ 2924static void cleanup_recv_queue(struct ib_mad_qp_info *qp_info) 2925{ 2926 struct ib_mad_private_header *mad_priv_hdr; 2927 struct ib_mad_private *recv; 2928 struct ib_mad_list_head *mad_list; 2929 2930 if (!qp_info->qp) 2931 return; 2932 2933 while (!list_empty(&qp_info->recv_queue.list)) { 2934 2935 mad_list = list_entry(qp_info->recv_queue.list.next, 2936 struct ib_mad_list_head, list); 2937 mad_priv_hdr = container_of(mad_list, 2938 struct ib_mad_private_header, 2939 mad_list); 2940 recv = container_of(mad_priv_hdr, struct ib_mad_private, 2941 header); 2942 2943 /* Remove from posted receive MAD list */ 2944 list_del(&mad_list->list); 2945 2946 ib_dma_unmap_single(qp_info->port_priv->device, 2947 recv->header.mapping, 2948 mad_priv_dma_size(recv), 2949 DMA_FROM_DEVICE); 2950 kfree(recv); 2951 } 2952 2953 qp_info->recv_queue.count = 0; 2954} 2955 2956/* 2957 * Start the port 2958 */ 2959static int ib_mad_port_start(struct ib_mad_port_private *port_priv) 2960{ 2961 int ret, i; 2962 struct ib_qp_attr *attr; 2963 struct ib_qp *qp; 2964 u16 pkey_index; 2965 2966 attr = kmalloc(sizeof *attr, GFP_KERNEL); 2967 if (!attr) { 2968 dev_err(&port_priv->device->dev, 2969 "Couldn't kmalloc ib_qp_attr\n"); 2970 return -ENOMEM; 2971 } 2972 2973 ret = ib_find_pkey(port_priv->device, port_priv->port_num, 2974 IB_DEFAULT_PKEY_FULL, &pkey_index); 2975 if (ret) 2976 pkey_index = 0; 2977 2978 for (i = 0; i < IB_MAD_QPS_CORE; i++) { 2979 qp = port_priv->qp_info[i].qp; 2980 if (!qp) 2981 continue; 2982 2983 /* 2984 * PKey index for QP1 is irrelevant but 2985 * one is needed for the Reset to Init transition 2986 */ 2987 attr->qp_state = IB_QPS_INIT; 2988 attr->pkey_index = pkey_index; 2989 attr->qkey = (qp->qp_num == 0) ? 0 : IB_QP1_QKEY; 2990 ret = ib_modify_qp(qp, attr, IB_QP_STATE | 2991 IB_QP_PKEY_INDEX | IB_QP_QKEY); 2992 if (ret) { 2993 dev_err(&port_priv->device->dev, 2994 "Couldn't change QP%d state to INIT: %d\n", 2995 i, ret); 2996 goto out; 2997 } 2998 2999 attr->qp_state = IB_QPS_RTR; 3000 ret = ib_modify_qp(qp, attr, IB_QP_STATE); 3001 if (ret) { 3002 dev_err(&port_priv->device->dev, 3003 "Couldn't change QP%d state to RTR: %d\n", 3004 i, ret); 3005 goto out; 3006 } 3007 3008 attr->qp_state = IB_QPS_RTS; 3009 attr->sq_psn = IB_MAD_SEND_Q_PSN; 3010 ret = ib_modify_qp(qp, attr, IB_QP_STATE | IB_QP_SQ_PSN); 3011 if (ret) { 3012 dev_err(&port_priv->device->dev, 3013 "Couldn't change QP%d state to RTS: %d\n", 3014 i, ret); 3015 goto out; 3016 } 3017 } 3018 3019 ret = ib_req_notify_cq(port_priv->cq, IB_CQ_NEXT_COMP); 3020 if (ret) { 3021 dev_err(&port_priv->device->dev, 3022 "Failed to request completion notification: %d\n", 3023 ret); 3024 goto out; 3025 } 3026 3027 for (i = 0; i < IB_MAD_QPS_CORE; i++) { 3028 if (!port_priv->qp_info[i].qp) 3029 continue; 3030 3031 ret = ib_mad_post_receive_mads(&port_priv->qp_info[i], NULL); 3032 if (ret) { 3033 dev_err(&port_priv->device->dev, 3034 "Couldn't post receive WRs\n"); 3035 goto out; 3036 } 3037 } 3038out: 3039 kfree(attr); 3040 return ret; 3041} 3042 3043static void qp_event_handler(struct ib_event *event, void *qp_context) 3044{ 3045 struct ib_mad_qp_info *qp_info = qp_context; 3046 3047 /* It's worse than that! He's dead, Jim! */ 3048 dev_err(&qp_info->port_priv->device->dev, 3049 "Fatal error (%d) on MAD QP (%d)\n", 3050 event->event, qp_info->qp->qp_num); 3051} 3052 3053static void init_mad_queue(struct ib_mad_qp_info *qp_info, 3054 struct ib_mad_queue *mad_queue) 3055{ 3056 mad_queue->qp_info = qp_info; 3057 mad_queue->count = 0; 3058 spin_lock_init(&mad_queue->lock); 3059 INIT_LIST_HEAD(&mad_queue->list); 3060} 3061 3062static void init_mad_qp(struct ib_mad_port_private *port_priv, 3063 struct ib_mad_qp_info *qp_info) 3064{ 3065 qp_info->port_priv = port_priv; 3066 init_mad_queue(qp_info, &qp_info->send_queue); 3067 init_mad_queue(qp_info, &qp_info->recv_queue); 3068 INIT_LIST_HEAD(&qp_info->overflow_list); 3069 spin_lock_init(&qp_info->snoop_lock); 3070 qp_info->snoop_table = NULL; 3071 qp_info->snoop_table_size = 0; 3072 atomic_set(&qp_info->snoop_count, 0); 3073} 3074 3075static int create_mad_qp(struct ib_mad_qp_info *qp_info, 3076 enum ib_qp_type qp_type) 3077{ 3078 struct ib_qp_init_attr qp_init_attr; 3079 int ret; 3080 3081 memset(&qp_init_attr, 0, sizeof qp_init_attr); 3082 qp_init_attr.send_cq = qp_info->port_priv->cq; 3083 qp_init_attr.recv_cq = qp_info->port_priv->cq; 3084 qp_init_attr.sq_sig_type = IB_SIGNAL_ALL_WR; 3085 qp_init_attr.cap.max_send_wr = mad_sendq_size; 3086 qp_init_attr.cap.max_recv_wr = mad_recvq_size; 3087 qp_init_attr.cap.max_send_sge = IB_MAD_SEND_REQ_MAX_SG; 3088 qp_init_attr.cap.max_recv_sge = IB_MAD_RECV_REQ_MAX_SG; 3089 qp_init_attr.qp_type = qp_type; 3090 qp_init_attr.port_num = qp_info->port_priv->port_num; 3091 qp_init_attr.qp_context = qp_info; 3092 qp_init_attr.event_handler = qp_event_handler; 3093 qp_info->qp = ib_create_qp(qp_info->port_priv->pd, &qp_init_attr); 3094 if (IS_ERR(qp_info->qp)) { 3095 dev_err(&qp_info->port_priv->device->dev, 3096 "Couldn't create ib_mad QP%d\n", 3097 get_spl_qp_index(qp_type)); 3098 ret = PTR_ERR(qp_info->qp); 3099 goto error; 3100 } 3101 /* Use minimum queue sizes unless the CQ is resized */ 3102 qp_info->send_queue.max_active = mad_sendq_size; 3103 qp_info->recv_queue.max_active = mad_recvq_size; 3104 return 0; 3105 3106error: 3107 return ret; 3108} 3109 3110static void destroy_mad_qp(struct ib_mad_qp_info *qp_info) 3111{ 3112 if (!qp_info->qp) 3113 return; 3114 3115 ib_destroy_qp(qp_info->qp); 3116 kfree(qp_info->snoop_table); 3117} 3118 3119/* 3120 * Open the port 3121 * Create the QP, PD, MR, and CQ if needed 3122 */ 3123static int ib_mad_port_open(struct ib_device *device, 3124 int port_num) 3125{ 3126 int ret, cq_size; 3127 struct ib_mad_port_private *port_priv; 3128 unsigned long flags; 3129 char name[sizeof "ib_mad123"]; 3130 int has_smi; 3131 3132 if (WARN_ON(rdma_max_mad_size(device, port_num) < IB_MGMT_MAD_SIZE)) 3133 return -EFAULT; 3134 3135 if (WARN_ON(rdma_cap_opa_mad(device, port_num) && 3136 rdma_max_mad_size(device, port_num) < OPA_MGMT_MAD_SIZE)) 3137 return -EFAULT; 3138 3139 /* Create new device info */ 3140 port_priv = kzalloc(sizeof *port_priv, GFP_KERNEL); 3141 if (!port_priv) { 3142 dev_err(&device->dev, "No memory for ib_mad_port_private\n"); 3143 return -ENOMEM; 3144 } 3145 3146 port_priv->device = device; 3147 port_priv->port_num = port_num; 3148 spin_lock_init(&port_priv->reg_lock); 3149 INIT_LIST_HEAD(&port_priv->agent_list); 3150 init_mad_qp(port_priv, &port_priv->qp_info[0]); 3151 init_mad_qp(port_priv, &port_priv->qp_info[1]); 3152 3153 cq_size = mad_sendq_size + mad_recvq_size; 3154 has_smi = rdma_cap_ib_smi(device, port_num); 3155 if (has_smi) 3156 cq_size *= 2; 3157 3158 port_priv->cq = ib_alloc_cq(port_priv->device, port_priv, cq_size, 0, 3159 IB_POLL_WORKQUEUE); 3160 if (IS_ERR(port_priv->cq)) { 3161 dev_err(&device->dev, "Couldn't create ib_mad CQ\n"); 3162 ret = PTR_ERR(port_priv->cq); 3163 goto error3; 3164 } 3165 3166 port_priv->pd = ib_alloc_pd(device, 0); 3167 if (IS_ERR(port_priv->pd)) { 3168 dev_err(&device->dev, "Couldn't create ib_mad PD\n"); 3169 ret = PTR_ERR(port_priv->pd); 3170 goto error4; 3171 } 3172 3173 if (has_smi) { 3174 ret = create_mad_qp(&port_priv->qp_info[0], IB_QPT_SMI); 3175 if (ret) 3176 goto error6; 3177 } 3178 ret = create_mad_qp(&port_priv->qp_info[1], IB_QPT_GSI); 3179 if (ret) 3180 goto error7; 3181 3182 snprintf(name, sizeof name, "ib_mad%d", port_num); 3183 port_priv->wq = alloc_ordered_workqueue(name, WQ_MEM_RECLAIM); 3184 if (!port_priv->wq) { 3185 ret = -ENOMEM; 3186 goto error8; 3187 } 3188 3189 spin_lock_irqsave(&ib_mad_port_list_lock, flags); 3190 list_add_tail(&port_priv->port_list, &ib_mad_port_list); 3191 spin_unlock_irqrestore(&ib_mad_port_list_lock, flags); 3192 3193 ret = ib_mad_port_start(port_priv); 3194 if (ret) { 3195 dev_err(&device->dev, "Couldn't start port\n"); 3196 goto error9; 3197 } 3198 3199 return 0; 3200 3201error9: 3202 spin_lock_irqsave(&ib_mad_port_list_lock, flags); 3203 list_del_init(&port_priv->port_list); 3204 spin_unlock_irqrestore(&ib_mad_port_list_lock, flags); 3205 3206 destroy_workqueue(port_priv->wq); 3207error8: 3208 destroy_mad_qp(&port_priv->qp_info[1]); 3209error7: 3210 destroy_mad_qp(&port_priv->qp_info[0]); 3211error6: 3212 ib_dealloc_pd(port_priv->pd); 3213error4: 3214 ib_free_cq(port_priv->cq); 3215 cleanup_recv_queue(&port_priv->qp_info[1]); 3216 cleanup_recv_queue(&port_priv->qp_info[0]); 3217error3: 3218 kfree(port_priv); 3219 3220 return ret; 3221} 3222 3223/* 3224 * Close the port 3225 * If there are no classes using the port, free the port 3226 * resources (CQ, MR, PD, QP) and remove the port's info structure 3227 */ 3228static int ib_mad_port_close(struct ib_device *device, int port_num) 3229{ 3230 struct ib_mad_port_private *port_priv; 3231 unsigned long flags; 3232 3233 spin_lock_irqsave(&ib_mad_port_list_lock, flags); 3234 port_priv = __ib_get_mad_port(device, port_num); 3235 if (port_priv == NULL) { 3236 spin_unlock_irqrestore(&ib_mad_port_list_lock, flags); 3237 dev_err(&device->dev, "Port %d not found\n", port_num); 3238 return -ENODEV; 3239 } 3240 list_del_init(&port_priv->port_list); 3241 spin_unlock_irqrestore(&ib_mad_port_list_lock, flags); 3242 3243 destroy_workqueue(port_priv->wq); 3244 destroy_mad_qp(&port_priv->qp_info[1]); 3245 destroy_mad_qp(&port_priv->qp_info[0]); 3246 ib_dealloc_pd(port_priv->pd); 3247 ib_free_cq(port_priv->cq); 3248 cleanup_recv_queue(&port_priv->qp_info[1]); 3249 cleanup_recv_queue(&port_priv->qp_info[0]); 3250 /* XXX: Handle deallocation of MAD registration tables */ 3251 3252 kfree(port_priv); 3253 3254 return 0; 3255} 3256 3257static void ib_mad_init_device(struct ib_device *device) 3258{ 3259 int start, i; 3260 3261 start = rdma_start_port(device); 3262 3263 for (i = start; i <= rdma_end_port(device); i++) { 3264 if (!rdma_cap_ib_mad(device, i)) 3265 continue; 3266 3267 if (ib_mad_port_open(device, i)) { 3268 dev_err(&device->dev, "Couldn't open port %d\n", i); 3269 goto error; 3270 } 3271 if (ib_agent_port_open(device, i)) { 3272 dev_err(&device->dev, 3273 "Couldn't open port %d for agents\n", i); 3274 goto error_agent; 3275 } 3276 } 3277 return; 3278 3279error_agent: 3280 if (ib_mad_port_close(device, i)) 3281 dev_err(&device->dev, "Couldn't close port %d\n", i); 3282 3283error: 3284 while (--i >= start) { 3285 if (!rdma_cap_ib_mad(device, i)) 3286 continue; 3287 3288 if (ib_agent_port_close(device, i)) 3289 dev_err(&device->dev, 3290 "Couldn't close port %d for agents\n", i); 3291 if (ib_mad_port_close(device, i)) 3292 dev_err(&device->dev, "Couldn't close port %d\n", i); 3293 } 3294} 3295 3296static void ib_mad_remove_device(struct ib_device *device, void *client_data) 3297{ 3298 int i; 3299 3300 for (i = rdma_start_port(device); i <= rdma_end_port(device); i++) { 3301 if (!rdma_cap_ib_mad(device, i)) 3302 continue; 3303 3304 if (ib_agent_port_close(device, i)) 3305 dev_err(&device->dev, 3306 "Couldn't close port %d for agents\n", i); 3307 if (ib_mad_port_close(device, i)) 3308 dev_err(&device->dev, "Couldn't close port %d\n", i); 3309 } 3310} 3311 3312static struct ib_client mad_client = { 3313 .name = "mad", 3314 .add = ib_mad_init_device, 3315 .remove = ib_mad_remove_device 3316}; 3317 3318int ib_mad_init(void) 3319{ 3320 mad_recvq_size = min(mad_recvq_size, IB_MAD_QP_MAX_SIZE); 3321 mad_recvq_size = max(mad_recvq_size, IB_MAD_QP_MIN_SIZE); 3322 3323 mad_sendq_size = min(mad_sendq_size, IB_MAD_QP_MAX_SIZE); 3324 mad_sendq_size = max(mad_sendq_size, IB_MAD_QP_MIN_SIZE); 3325 3326 INIT_LIST_HEAD(&ib_mad_port_list); 3327 3328 if (ib_register_client(&mad_client)) { 3329 pr_err("Couldn't register ib_mad client\n"); 3330 return -EINVAL; 3331 } 3332 3333 return 0; 3334} 3335 3336void ib_mad_cleanup(void) 3337{ 3338 ib_unregister_client(&mad_client); 3339} 3340