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