1 /* 2 * Copyright (c) 2004 Topspin Communications. All rights reserved. 3 * Copyright (c) 2005 Voltaire, Inc. All rights reserved. 4 * Copyright (c) 2006 Intel Corporation. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 */ 34 35 #include <linux/module.h> 36 #include <linux/init.h> 37 #include <linux/err.h> 38 #include <linux/random.h> 39 #include <linux/spinlock.h> 40 #include <linux/slab.h> 41 #include <linux/dma-mapping.h> 42 #include <linux/kref.h> 43 #include <linux/idr.h> 44 #include <linux/workqueue.h> 45 #include <uapi/linux/if_ether.h> 46 #include <rdma/ib_pack.h> 47 #include <rdma/ib_cache.h> 48 #include <rdma/rdma_netlink.h> 49 #include <net/netlink.h> 50 #include <uapi/rdma/ib_user_sa.h> 51 #include <rdma/ib_marshall.h> 52 #include <rdma/ib_addr.h> 53 #include <rdma/opa_addr.h> 54 #include "sa.h" 55 #include "core_priv.h" 56 57 #define IB_SA_LOCAL_SVC_TIMEOUT_MIN 100 58 #define IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT 2000 59 #define IB_SA_LOCAL_SVC_TIMEOUT_MAX 200000 60 #define IB_SA_CPI_MAX_RETRY_CNT 3 61 #define IB_SA_CPI_RETRY_WAIT 1000 /*msecs */ 62 static int sa_local_svc_timeout_ms = IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT; 63 64 struct ib_sa_sm_ah { 65 struct ib_ah *ah; 66 struct kref ref; 67 u16 pkey_index; 68 u8 src_path_mask; 69 }; 70 71 enum rdma_class_port_info_type { 72 RDMA_CLASS_PORT_INFO_IB, 73 RDMA_CLASS_PORT_INFO_OPA 74 }; 75 76 struct rdma_class_port_info { 77 enum rdma_class_port_info_type type; 78 union { 79 struct ib_class_port_info ib; 80 struct opa_class_port_info opa; 81 }; 82 }; 83 84 struct ib_sa_classport_cache { 85 bool valid; 86 int retry_cnt; 87 struct rdma_class_port_info data; 88 }; 89 90 struct ib_sa_port { 91 struct ib_mad_agent *agent; 92 struct ib_sa_sm_ah *sm_ah; 93 struct work_struct update_task; 94 struct ib_sa_classport_cache classport_info; 95 struct delayed_work ib_cpi_work; 96 spinlock_t classport_lock; /* protects class port info set */ 97 spinlock_t ah_lock; 98 u8 port_num; 99 }; 100 101 struct ib_sa_device { 102 int start_port, end_port; 103 struct ib_event_handler event_handler; 104 struct ib_sa_port port[0]; 105 }; 106 107 struct ib_sa_query { 108 void (*callback)(struct ib_sa_query *, int, struct ib_sa_mad *); 109 void (*release)(struct ib_sa_query *); 110 struct ib_sa_client *client; 111 struct ib_sa_port *port; 112 struct ib_mad_send_buf *mad_buf; 113 struct ib_sa_sm_ah *sm_ah; 114 int id; 115 u32 flags; 116 struct list_head list; /* Local svc request list */ 117 u32 seq; /* Local svc request sequence number */ 118 unsigned long timeout; /* Local svc timeout */ 119 u8 path_use; /* How will the pathrecord be used */ 120 }; 121 122 #define IB_SA_ENABLE_LOCAL_SERVICE 0x00000001 123 #define IB_SA_CANCEL 0x00000002 124 #define IB_SA_QUERY_OPA 0x00000004 125 126 struct ib_sa_service_query { 127 void (*callback)(int, struct ib_sa_service_rec *, void *); 128 void *context; 129 struct ib_sa_query sa_query; 130 }; 131 132 struct ib_sa_path_query { 133 void (*callback)(int, struct sa_path_rec *, void *); 134 void *context; 135 struct ib_sa_query sa_query; 136 struct sa_path_rec *conv_pr; 137 }; 138 139 struct ib_sa_guidinfo_query { 140 void (*callback)(int, struct ib_sa_guidinfo_rec *, void *); 141 void *context; 142 struct ib_sa_query sa_query; 143 }; 144 145 struct ib_sa_classport_info_query { 146 void (*callback)(void *); 147 void *context; 148 struct ib_sa_query sa_query; 149 }; 150 151 struct ib_sa_mcmember_query { 152 void (*callback)(int, struct ib_sa_mcmember_rec *, void *); 153 void *context; 154 struct ib_sa_query sa_query; 155 }; 156 157 static LIST_HEAD(ib_nl_request_list); 158 static DEFINE_SPINLOCK(ib_nl_request_lock); 159 static atomic_t ib_nl_sa_request_seq; 160 static struct workqueue_struct *ib_nl_wq; 161 static struct delayed_work ib_nl_timed_work; 162 static const struct nla_policy ib_nl_policy[LS_NLA_TYPE_MAX] = { 163 [LS_NLA_TYPE_PATH_RECORD] = {.type = NLA_BINARY, 164 .len = sizeof(struct ib_path_rec_data)}, 165 [LS_NLA_TYPE_TIMEOUT] = {.type = NLA_U32}, 166 [LS_NLA_TYPE_SERVICE_ID] = {.type = NLA_U64}, 167 [LS_NLA_TYPE_DGID] = {.type = NLA_BINARY, 168 .len = sizeof(struct rdma_nla_ls_gid)}, 169 [LS_NLA_TYPE_SGID] = {.type = NLA_BINARY, 170 .len = sizeof(struct rdma_nla_ls_gid)}, 171 [LS_NLA_TYPE_TCLASS] = {.type = NLA_U8}, 172 [LS_NLA_TYPE_PKEY] = {.type = NLA_U16}, 173 [LS_NLA_TYPE_QOS_CLASS] = {.type = NLA_U16}, 174 }; 175 176 177 static void ib_sa_add_one(struct ib_device *device); 178 static void ib_sa_remove_one(struct ib_device *device, void *client_data); 179 180 static struct ib_client sa_client = { 181 .name = "sa", 182 .add = ib_sa_add_one, 183 .remove = ib_sa_remove_one 184 }; 185 186 static DEFINE_SPINLOCK(idr_lock); 187 static DEFINE_IDR(query_idr); 188 189 static DEFINE_SPINLOCK(tid_lock); 190 static u32 tid; 191 192 #define PATH_REC_FIELD(field) \ 193 .struct_offset_bytes = offsetof(struct sa_path_rec, field), \ 194 .struct_size_bytes = sizeof((struct sa_path_rec *)0)->field, \ 195 .field_name = "sa_path_rec:" #field 196 197 static const struct ib_field path_rec_table[] = { 198 { PATH_REC_FIELD(service_id), 199 .offset_words = 0, 200 .offset_bits = 0, 201 .size_bits = 64 }, 202 { PATH_REC_FIELD(dgid), 203 .offset_words = 2, 204 .offset_bits = 0, 205 .size_bits = 128 }, 206 { PATH_REC_FIELD(sgid), 207 .offset_words = 6, 208 .offset_bits = 0, 209 .size_bits = 128 }, 210 { PATH_REC_FIELD(ib.dlid), 211 .offset_words = 10, 212 .offset_bits = 0, 213 .size_bits = 16 }, 214 { PATH_REC_FIELD(ib.slid), 215 .offset_words = 10, 216 .offset_bits = 16, 217 .size_bits = 16 }, 218 { PATH_REC_FIELD(ib.raw_traffic), 219 .offset_words = 11, 220 .offset_bits = 0, 221 .size_bits = 1 }, 222 { RESERVED, 223 .offset_words = 11, 224 .offset_bits = 1, 225 .size_bits = 3 }, 226 { PATH_REC_FIELD(flow_label), 227 .offset_words = 11, 228 .offset_bits = 4, 229 .size_bits = 20 }, 230 { PATH_REC_FIELD(hop_limit), 231 .offset_words = 11, 232 .offset_bits = 24, 233 .size_bits = 8 }, 234 { PATH_REC_FIELD(traffic_class), 235 .offset_words = 12, 236 .offset_bits = 0, 237 .size_bits = 8 }, 238 { PATH_REC_FIELD(reversible), 239 .offset_words = 12, 240 .offset_bits = 8, 241 .size_bits = 1 }, 242 { PATH_REC_FIELD(numb_path), 243 .offset_words = 12, 244 .offset_bits = 9, 245 .size_bits = 7 }, 246 { PATH_REC_FIELD(pkey), 247 .offset_words = 12, 248 .offset_bits = 16, 249 .size_bits = 16 }, 250 { PATH_REC_FIELD(qos_class), 251 .offset_words = 13, 252 .offset_bits = 0, 253 .size_bits = 12 }, 254 { PATH_REC_FIELD(sl), 255 .offset_words = 13, 256 .offset_bits = 12, 257 .size_bits = 4 }, 258 { PATH_REC_FIELD(mtu_selector), 259 .offset_words = 13, 260 .offset_bits = 16, 261 .size_bits = 2 }, 262 { PATH_REC_FIELD(mtu), 263 .offset_words = 13, 264 .offset_bits = 18, 265 .size_bits = 6 }, 266 { PATH_REC_FIELD(rate_selector), 267 .offset_words = 13, 268 .offset_bits = 24, 269 .size_bits = 2 }, 270 { PATH_REC_FIELD(rate), 271 .offset_words = 13, 272 .offset_bits = 26, 273 .size_bits = 6 }, 274 { PATH_REC_FIELD(packet_life_time_selector), 275 .offset_words = 14, 276 .offset_bits = 0, 277 .size_bits = 2 }, 278 { PATH_REC_FIELD(packet_life_time), 279 .offset_words = 14, 280 .offset_bits = 2, 281 .size_bits = 6 }, 282 { PATH_REC_FIELD(preference), 283 .offset_words = 14, 284 .offset_bits = 8, 285 .size_bits = 8 }, 286 { RESERVED, 287 .offset_words = 14, 288 .offset_bits = 16, 289 .size_bits = 48 }, 290 }; 291 292 #define OPA_PATH_REC_FIELD(field) \ 293 .struct_offset_bytes = \ 294 offsetof(struct sa_path_rec, field), \ 295 .struct_size_bytes = \ 296 sizeof((struct sa_path_rec *)0)->field, \ 297 .field_name = "sa_path_rec:" #field 298 299 static const struct ib_field opa_path_rec_table[] = { 300 { OPA_PATH_REC_FIELD(service_id), 301 .offset_words = 0, 302 .offset_bits = 0, 303 .size_bits = 64 }, 304 { OPA_PATH_REC_FIELD(dgid), 305 .offset_words = 2, 306 .offset_bits = 0, 307 .size_bits = 128 }, 308 { OPA_PATH_REC_FIELD(sgid), 309 .offset_words = 6, 310 .offset_bits = 0, 311 .size_bits = 128 }, 312 { OPA_PATH_REC_FIELD(opa.dlid), 313 .offset_words = 10, 314 .offset_bits = 0, 315 .size_bits = 32 }, 316 { OPA_PATH_REC_FIELD(opa.slid), 317 .offset_words = 11, 318 .offset_bits = 0, 319 .size_bits = 32 }, 320 { OPA_PATH_REC_FIELD(opa.raw_traffic), 321 .offset_words = 12, 322 .offset_bits = 0, 323 .size_bits = 1 }, 324 { RESERVED, 325 .offset_words = 12, 326 .offset_bits = 1, 327 .size_bits = 3 }, 328 { OPA_PATH_REC_FIELD(flow_label), 329 .offset_words = 12, 330 .offset_bits = 4, 331 .size_bits = 20 }, 332 { OPA_PATH_REC_FIELD(hop_limit), 333 .offset_words = 12, 334 .offset_bits = 24, 335 .size_bits = 8 }, 336 { OPA_PATH_REC_FIELD(traffic_class), 337 .offset_words = 13, 338 .offset_bits = 0, 339 .size_bits = 8 }, 340 { OPA_PATH_REC_FIELD(reversible), 341 .offset_words = 13, 342 .offset_bits = 8, 343 .size_bits = 1 }, 344 { OPA_PATH_REC_FIELD(numb_path), 345 .offset_words = 13, 346 .offset_bits = 9, 347 .size_bits = 7 }, 348 { OPA_PATH_REC_FIELD(pkey), 349 .offset_words = 13, 350 .offset_bits = 16, 351 .size_bits = 16 }, 352 { OPA_PATH_REC_FIELD(opa.l2_8B), 353 .offset_words = 14, 354 .offset_bits = 0, 355 .size_bits = 1 }, 356 { OPA_PATH_REC_FIELD(opa.l2_10B), 357 .offset_words = 14, 358 .offset_bits = 1, 359 .size_bits = 1 }, 360 { OPA_PATH_REC_FIELD(opa.l2_9B), 361 .offset_words = 14, 362 .offset_bits = 2, 363 .size_bits = 1 }, 364 { OPA_PATH_REC_FIELD(opa.l2_16B), 365 .offset_words = 14, 366 .offset_bits = 3, 367 .size_bits = 1 }, 368 { RESERVED, 369 .offset_words = 14, 370 .offset_bits = 4, 371 .size_bits = 2 }, 372 { OPA_PATH_REC_FIELD(opa.qos_type), 373 .offset_words = 14, 374 .offset_bits = 6, 375 .size_bits = 2 }, 376 { OPA_PATH_REC_FIELD(opa.qos_priority), 377 .offset_words = 14, 378 .offset_bits = 8, 379 .size_bits = 8 }, 380 { RESERVED, 381 .offset_words = 14, 382 .offset_bits = 16, 383 .size_bits = 3 }, 384 { OPA_PATH_REC_FIELD(sl), 385 .offset_words = 14, 386 .offset_bits = 19, 387 .size_bits = 5 }, 388 { RESERVED, 389 .offset_words = 14, 390 .offset_bits = 24, 391 .size_bits = 8 }, 392 { OPA_PATH_REC_FIELD(mtu_selector), 393 .offset_words = 15, 394 .offset_bits = 0, 395 .size_bits = 2 }, 396 { OPA_PATH_REC_FIELD(mtu), 397 .offset_words = 15, 398 .offset_bits = 2, 399 .size_bits = 6 }, 400 { OPA_PATH_REC_FIELD(rate_selector), 401 .offset_words = 15, 402 .offset_bits = 8, 403 .size_bits = 2 }, 404 { OPA_PATH_REC_FIELD(rate), 405 .offset_words = 15, 406 .offset_bits = 10, 407 .size_bits = 6 }, 408 { OPA_PATH_REC_FIELD(packet_life_time_selector), 409 .offset_words = 15, 410 .offset_bits = 16, 411 .size_bits = 2 }, 412 { OPA_PATH_REC_FIELD(packet_life_time), 413 .offset_words = 15, 414 .offset_bits = 18, 415 .size_bits = 6 }, 416 { OPA_PATH_REC_FIELD(preference), 417 .offset_words = 15, 418 .offset_bits = 24, 419 .size_bits = 8 }, 420 }; 421 422 #define MCMEMBER_REC_FIELD(field) \ 423 .struct_offset_bytes = offsetof(struct ib_sa_mcmember_rec, field), \ 424 .struct_size_bytes = sizeof ((struct ib_sa_mcmember_rec *) 0)->field, \ 425 .field_name = "sa_mcmember_rec:" #field 426 427 static const struct ib_field mcmember_rec_table[] = { 428 { MCMEMBER_REC_FIELD(mgid), 429 .offset_words = 0, 430 .offset_bits = 0, 431 .size_bits = 128 }, 432 { MCMEMBER_REC_FIELD(port_gid), 433 .offset_words = 4, 434 .offset_bits = 0, 435 .size_bits = 128 }, 436 { MCMEMBER_REC_FIELD(qkey), 437 .offset_words = 8, 438 .offset_bits = 0, 439 .size_bits = 32 }, 440 { MCMEMBER_REC_FIELD(mlid), 441 .offset_words = 9, 442 .offset_bits = 0, 443 .size_bits = 16 }, 444 { MCMEMBER_REC_FIELD(mtu_selector), 445 .offset_words = 9, 446 .offset_bits = 16, 447 .size_bits = 2 }, 448 { MCMEMBER_REC_FIELD(mtu), 449 .offset_words = 9, 450 .offset_bits = 18, 451 .size_bits = 6 }, 452 { MCMEMBER_REC_FIELD(traffic_class), 453 .offset_words = 9, 454 .offset_bits = 24, 455 .size_bits = 8 }, 456 { MCMEMBER_REC_FIELD(pkey), 457 .offset_words = 10, 458 .offset_bits = 0, 459 .size_bits = 16 }, 460 { MCMEMBER_REC_FIELD(rate_selector), 461 .offset_words = 10, 462 .offset_bits = 16, 463 .size_bits = 2 }, 464 { MCMEMBER_REC_FIELD(rate), 465 .offset_words = 10, 466 .offset_bits = 18, 467 .size_bits = 6 }, 468 { MCMEMBER_REC_FIELD(packet_life_time_selector), 469 .offset_words = 10, 470 .offset_bits = 24, 471 .size_bits = 2 }, 472 { MCMEMBER_REC_FIELD(packet_life_time), 473 .offset_words = 10, 474 .offset_bits = 26, 475 .size_bits = 6 }, 476 { MCMEMBER_REC_FIELD(sl), 477 .offset_words = 11, 478 .offset_bits = 0, 479 .size_bits = 4 }, 480 { MCMEMBER_REC_FIELD(flow_label), 481 .offset_words = 11, 482 .offset_bits = 4, 483 .size_bits = 20 }, 484 { MCMEMBER_REC_FIELD(hop_limit), 485 .offset_words = 11, 486 .offset_bits = 24, 487 .size_bits = 8 }, 488 { MCMEMBER_REC_FIELD(scope), 489 .offset_words = 12, 490 .offset_bits = 0, 491 .size_bits = 4 }, 492 { MCMEMBER_REC_FIELD(join_state), 493 .offset_words = 12, 494 .offset_bits = 4, 495 .size_bits = 4 }, 496 { MCMEMBER_REC_FIELD(proxy_join), 497 .offset_words = 12, 498 .offset_bits = 8, 499 .size_bits = 1 }, 500 { RESERVED, 501 .offset_words = 12, 502 .offset_bits = 9, 503 .size_bits = 23 }, 504 }; 505 506 #define SERVICE_REC_FIELD(field) \ 507 .struct_offset_bytes = offsetof(struct ib_sa_service_rec, field), \ 508 .struct_size_bytes = sizeof ((struct ib_sa_service_rec *) 0)->field, \ 509 .field_name = "sa_service_rec:" #field 510 511 static const struct ib_field service_rec_table[] = { 512 { SERVICE_REC_FIELD(id), 513 .offset_words = 0, 514 .offset_bits = 0, 515 .size_bits = 64 }, 516 { SERVICE_REC_FIELD(gid), 517 .offset_words = 2, 518 .offset_bits = 0, 519 .size_bits = 128 }, 520 { SERVICE_REC_FIELD(pkey), 521 .offset_words = 6, 522 .offset_bits = 0, 523 .size_bits = 16 }, 524 { SERVICE_REC_FIELD(lease), 525 .offset_words = 7, 526 .offset_bits = 0, 527 .size_bits = 32 }, 528 { SERVICE_REC_FIELD(key), 529 .offset_words = 8, 530 .offset_bits = 0, 531 .size_bits = 128 }, 532 { SERVICE_REC_FIELD(name), 533 .offset_words = 12, 534 .offset_bits = 0, 535 .size_bits = 64*8 }, 536 { SERVICE_REC_FIELD(data8), 537 .offset_words = 28, 538 .offset_bits = 0, 539 .size_bits = 16*8 }, 540 { SERVICE_REC_FIELD(data16), 541 .offset_words = 32, 542 .offset_bits = 0, 543 .size_bits = 8*16 }, 544 { SERVICE_REC_FIELD(data32), 545 .offset_words = 36, 546 .offset_bits = 0, 547 .size_bits = 4*32 }, 548 { SERVICE_REC_FIELD(data64), 549 .offset_words = 40, 550 .offset_bits = 0, 551 .size_bits = 2*64 }, 552 }; 553 554 #define CLASSPORTINFO_REC_FIELD(field) \ 555 .struct_offset_bytes = offsetof(struct ib_class_port_info, field), \ 556 .struct_size_bytes = sizeof((struct ib_class_port_info *)0)->field, \ 557 .field_name = "ib_class_port_info:" #field 558 559 static const struct ib_field ib_classport_info_rec_table[] = { 560 { CLASSPORTINFO_REC_FIELD(base_version), 561 .offset_words = 0, 562 .offset_bits = 0, 563 .size_bits = 8 }, 564 { CLASSPORTINFO_REC_FIELD(class_version), 565 .offset_words = 0, 566 .offset_bits = 8, 567 .size_bits = 8 }, 568 { CLASSPORTINFO_REC_FIELD(capability_mask), 569 .offset_words = 0, 570 .offset_bits = 16, 571 .size_bits = 16 }, 572 { CLASSPORTINFO_REC_FIELD(cap_mask2_resp_time), 573 .offset_words = 1, 574 .offset_bits = 0, 575 .size_bits = 32 }, 576 { CLASSPORTINFO_REC_FIELD(redirect_gid), 577 .offset_words = 2, 578 .offset_bits = 0, 579 .size_bits = 128 }, 580 { CLASSPORTINFO_REC_FIELD(redirect_tcslfl), 581 .offset_words = 6, 582 .offset_bits = 0, 583 .size_bits = 32 }, 584 { CLASSPORTINFO_REC_FIELD(redirect_lid), 585 .offset_words = 7, 586 .offset_bits = 0, 587 .size_bits = 16 }, 588 { CLASSPORTINFO_REC_FIELD(redirect_pkey), 589 .offset_words = 7, 590 .offset_bits = 16, 591 .size_bits = 16 }, 592 593 { CLASSPORTINFO_REC_FIELD(redirect_qp), 594 .offset_words = 8, 595 .offset_bits = 0, 596 .size_bits = 32 }, 597 { CLASSPORTINFO_REC_FIELD(redirect_qkey), 598 .offset_words = 9, 599 .offset_bits = 0, 600 .size_bits = 32 }, 601 602 { CLASSPORTINFO_REC_FIELD(trap_gid), 603 .offset_words = 10, 604 .offset_bits = 0, 605 .size_bits = 128 }, 606 { CLASSPORTINFO_REC_FIELD(trap_tcslfl), 607 .offset_words = 14, 608 .offset_bits = 0, 609 .size_bits = 32 }, 610 611 { CLASSPORTINFO_REC_FIELD(trap_lid), 612 .offset_words = 15, 613 .offset_bits = 0, 614 .size_bits = 16 }, 615 { CLASSPORTINFO_REC_FIELD(trap_pkey), 616 .offset_words = 15, 617 .offset_bits = 16, 618 .size_bits = 16 }, 619 620 { CLASSPORTINFO_REC_FIELD(trap_hlqp), 621 .offset_words = 16, 622 .offset_bits = 0, 623 .size_bits = 32 }, 624 { CLASSPORTINFO_REC_FIELD(trap_qkey), 625 .offset_words = 17, 626 .offset_bits = 0, 627 .size_bits = 32 }, 628 }; 629 630 #define OPA_CLASSPORTINFO_REC_FIELD(field) \ 631 .struct_offset_bytes =\ 632 offsetof(struct opa_class_port_info, field), \ 633 .struct_size_bytes = \ 634 sizeof((struct opa_class_port_info *)0)->field, \ 635 .field_name = "opa_class_port_info:" #field 636 637 static const struct ib_field opa_classport_info_rec_table[] = { 638 { OPA_CLASSPORTINFO_REC_FIELD(base_version), 639 .offset_words = 0, 640 .offset_bits = 0, 641 .size_bits = 8 }, 642 { OPA_CLASSPORTINFO_REC_FIELD(class_version), 643 .offset_words = 0, 644 .offset_bits = 8, 645 .size_bits = 8 }, 646 { OPA_CLASSPORTINFO_REC_FIELD(cap_mask), 647 .offset_words = 0, 648 .offset_bits = 16, 649 .size_bits = 16 }, 650 { OPA_CLASSPORTINFO_REC_FIELD(cap_mask2_resp_time), 651 .offset_words = 1, 652 .offset_bits = 0, 653 .size_bits = 32 }, 654 { OPA_CLASSPORTINFO_REC_FIELD(redirect_gid), 655 .offset_words = 2, 656 .offset_bits = 0, 657 .size_bits = 128 }, 658 { OPA_CLASSPORTINFO_REC_FIELD(redirect_tc_fl), 659 .offset_words = 6, 660 .offset_bits = 0, 661 .size_bits = 32 }, 662 { OPA_CLASSPORTINFO_REC_FIELD(redirect_lid), 663 .offset_words = 7, 664 .offset_bits = 0, 665 .size_bits = 32 }, 666 { OPA_CLASSPORTINFO_REC_FIELD(redirect_sl_qp), 667 .offset_words = 8, 668 .offset_bits = 0, 669 .size_bits = 32 }, 670 { OPA_CLASSPORTINFO_REC_FIELD(redirect_qkey), 671 .offset_words = 9, 672 .offset_bits = 0, 673 .size_bits = 32 }, 674 { OPA_CLASSPORTINFO_REC_FIELD(trap_gid), 675 .offset_words = 10, 676 .offset_bits = 0, 677 .size_bits = 128 }, 678 { OPA_CLASSPORTINFO_REC_FIELD(trap_tc_fl), 679 .offset_words = 14, 680 .offset_bits = 0, 681 .size_bits = 32 }, 682 { OPA_CLASSPORTINFO_REC_FIELD(trap_lid), 683 .offset_words = 15, 684 .offset_bits = 0, 685 .size_bits = 32 }, 686 { OPA_CLASSPORTINFO_REC_FIELD(trap_hl_qp), 687 .offset_words = 16, 688 .offset_bits = 0, 689 .size_bits = 32 }, 690 { OPA_CLASSPORTINFO_REC_FIELD(trap_qkey), 691 .offset_words = 17, 692 .offset_bits = 0, 693 .size_bits = 32 }, 694 { OPA_CLASSPORTINFO_REC_FIELD(trap_pkey), 695 .offset_words = 18, 696 .offset_bits = 0, 697 .size_bits = 16 }, 698 { OPA_CLASSPORTINFO_REC_FIELD(redirect_pkey), 699 .offset_words = 18, 700 .offset_bits = 16, 701 .size_bits = 16 }, 702 { OPA_CLASSPORTINFO_REC_FIELD(trap_sl_rsvd), 703 .offset_words = 19, 704 .offset_bits = 0, 705 .size_bits = 8 }, 706 { RESERVED, 707 .offset_words = 19, 708 .offset_bits = 8, 709 .size_bits = 24 }, 710 }; 711 712 #define GUIDINFO_REC_FIELD(field) \ 713 .struct_offset_bytes = offsetof(struct ib_sa_guidinfo_rec, field), \ 714 .struct_size_bytes = sizeof((struct ib_sa_guidinfo_rec *) 0)->field, \ 715 .field_name = "sa_guidinfo_rec:" #field 716 717 static const struct ib_field guidinfo_rec_table[] = { 718 { GUIDINFO_REC_FIELD(lid), 719 .offset_words = 0, 720 .offset_bits = 0, 721 .size_bits = 16 }, 722 { GUIDINFO_REC_FIELD(block_num), 723 .offset_words = 0, 724 .offset_bits = 16, 725 .size_bits = 8 }, 726 { GUIDINFO_REC_FIELD(res1), 727 .offset_words = 0, 728 .offset_bits = 24, 729 .size_bits = 8 }, 730 { GUIDINFO_REC_FIELD(res2), 731 .offset_words = 1, 732 .offset_bits = 0, 733 .size_bits = 32 }, 734 { GUIDINFO_REC_FIELD(guid_info_list), 735 .offset_words = 2, 736 .offset_bits = 0, 737 .size_bits = 512 }, 738 }; 739 740 static inline void ib_sa_disable_local_svc(struct ib_sa_query *query) 741 { 742 query->flags &= ~IB_SA_ENABLE_LOCAL_SERVICE; 743 } 744 745 static inline int ib_sa_query_cancelled(struct ib_sa_query *query) 746 { 747 return (query->flags & IB_SA_CANCEL); 748 } 749 750 static void ib_nl_set_path_rec_attrs(struct sk_buff *skb, 751 struct ib_sa_query *query) 752 { 753 struct sa_path_rec *sa_rec = query->mad_buf->context[1]; 754 struct ib_sa_mad *mad = query->mad_buf->mad; 755 ib_sa_comp_mask comp_mask = mad->sa_hdr.comp_mask; 756 u16 val16; 757 u64 val64; 758 struct rdma_ls_resolve_header *header; 759 760 query->mad_buf->context[1] = NULL; 761 762 /* Construct the family header first */ 763 header = skb_put(skb, NLMSG_ALIGN(sizeof(*header))); 764 memcpy(header->device_name, dev_name(&query->port->agent->device->dev), 765 LS_DEVICE_NAME_MAX); 766 header->port_num = query->port->port_num; 767 768 if ((comp_mask & IB_SA_PATH_REC_REVERSIBLE) && 769 sa_rec->reversible != 0) 770 query->path_use = LS_RESOLVE_PATH_USE_GMP; 771 else 772 query->path_use = LS_RESOLVE_PATH_USE_UNIDIRECTIONAL; 773 header->path_use = query->path_use; 774 775 /* Now build the attributes */ 776 if (comp_mask & IB_SA_PATH_REC_SERVICE_ID) { 777 val64 = be64_to_cpu(sa_rec->service_id); 778 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_SERVICE_ID, 779 sizeof(val64), &val64); 780 } 781 if (comp_mask & IB_SA_PATH_REC_DGID) 782 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_DGID, 783 sizeof(sa_rec->dgid), &sa_rec->dgid); 784 if (comp_mask & IB_SA_PATH_REC_SGID) 785 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_SGID, 786 sizeof(sa_rec->sgid), &sa_rec->sgid); 787 if (comp_mask & IB_SA_PATH_REC_TRAFFIC_CLASS) 788 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_TCLASS, 789 sizeof(sa_rec->traffic_class), &sa_rec->traffic_class); 790 791 if (comp_mask & IB_SA_PATH_REC_PKEY) { 792 val16 = be16_to_cpu(sa_rec->pkey); 793 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_PKEY, 794 sizeof(val16), &val16); 795 } 796 if (comp_mask & IB_SA_PATH_REC_QOS_CLASS) { 797 val16 = be16_to_cpu(sa_rec->qos_class); 798 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_QOS_CLASS, 799 sizeof(val16), &val16); 800 } 801 } 802 803 static int ib_nl_get_path_rec_attrs_len(ib_sa_comp_mask comp_mask) 804 { 805 int len = 0; 806 807 if (comp_mask & IB_SA_PATH_REC_SERVICE_ID) 808 len += nla_total_size(sizeof(u64)); 809 if (comp_mask & IB_SA_PATH_REC_DGID) 810 len += nla_total_size(sizeof(struct rdma_nla_ls_gid)); 811 if (comp_mask & IB_SA_PATH_REC_SGID) 812 len += nla_total_size(sizeof(struct rdma_nla_ls_gid)); 813 if (comp_mask & IB_SA_PATH_REC_TRAFFIC_CLASS) 814 len += nla_total_size(sizeof(u8)); 815 if (comp_mask & IB_SA_PATH_REC_PKEY) 816 len += nla_total_size(sizeof(u16)); 817 if (comp_mask & IB_SA_PATH_REC_QOS_CLASS) 818 len += nla_total_size(sizeof(u16)); 819 820 /* 821 * Make sure that at least some of the required comp_mask bits are 822 * set. 823 */ 824 if (WARN_ON(len == 0)) 825 return len; 826 827 /* Add the family header */ 828 len += NLMSG_ALIGN(sizeof(struct rdma_ls_resolve_header)); 829 830 return len; 831 } 832 833 static int ib_nl_send_msg(struct ib_sa_query *query, gfp_t gfp_mask) 834 { 835 struct sk_buff *skb = NULL; 836 struct nlmsghdr *nlh; 837 void *data; 838 struct ib_sa_mad *mad; 839 int len; 840 841 mad = query->mad_buf->mad; 842 len = ib_nl_get_path_rec_attrs_len(mad->sa_hdr.comp_mask); 843 if (len <= 0) 844 return -EMSGSIZE; 845 846 skb = nlmsg_new(len, gfp_mask); 847 if (!skb) 848 return -ENOMEM; 849 850 /* Put nlmsg header only for now */ 851 data = ibnl_put_msg(skb, &nlh, query->seq, 0, RDMA_NL_LS, 852 RDMA_NL_LS_OP_RESOLVE, NLM_F_REQUEST); 853 if (!data) { 854 nlmsg_free(skb); 855 return -EMSGSIZE; 856 } 857 858 /* Add attributes */ 859 ib_nl_set_path_rec_attrs(skb, query); 860 861 /* Repair the nlmsg header length */ 862 nlmsg_end(skb, nlh); 863 864 return rdma_nl_multicast(skb, RDMA_NL_GROUP_LS, gfp_mask); 865 } 866 867 static int ib_nl_make_request(struct ib_sa_query *query, gfp_t gfp_mask) 868 { 869 unsigned long flags; 870 unsigned long delay; 871 int ret; 872 873 INIT_LIST_HEAD(&query->list); 874 query->seq = (u32)atomic_inc_return(&ib_nl_sa_request_seq); 875 876 /* Put the request on the list first.*/ 877 spin_lock_irqsave(&ib_nl_request_lock, flags); 878 delay = msecs_to_jiffies(sa_local_svc_timeout_ms); 879 query->timeout = delay + jiffies; 880 list_add_tail(&query->list, &ib_nl_request_list); 881 /* Start the timeout if this is the only request */ 882 if (ib_nl_request_list.next == &query->list) 883 queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay); 884 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 885 886 ret = ib_nl_send_msg(query, gfp_mask); 887 if (ret) { 888 ret = -EIO; 889 /* Remove the request */ 890 spin_lock_irqsave(&ib_nl_request_lock, flags); 891 list_del(&query->list); 892 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 893 } 894 895 return ret; 896 } 897 898 static int ib_nl_cancel_request(struct ib_sa_query *query) 899 { 900 unsigned long flags; 901 struct ib_sa_query *wait_query; 902 int found = 0; 903 904 spin_lock_irqsave(&ib_nl_request_lock, flags); 905 list_for_each_entry(wait_query, &ib_nl_request_list, list) { 906 /* Let the timeout to take care of the callback */ 907 if (query == wait_query) { 908 query->flags |= IB_SA_CANCEL; 909 query->timeout = jiffies; 910 list_move(&query->list, &ib_nl_request_list); 911 found = 1; 912 mod_delayed_work(ib_nl_wq, &ib_nl_timed_work, 1); 913 break; 914 } 915 } 916 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 917 918 return found; 919 } 920 921 static void send_handler(struct ib_mad_agent *agent, 922 struct ib_mad_send_wc *mad_send_wc); 923 924 static void ib_nl_process_good_resolve_rsp(struct ib_sa_query *query, 925 const struct nlmsghdr *nlh) 926 { 927 struct ib_mad_send_wc mad_send_wc; 928 struct ib_sa_mad *mad = NULL; 929 const struct nlattr *head, *curr; 930 struct ib_path_rec_data *rec; 931 int len, rem; 932 u32 mask = 0; 933 int status = -EIO; 934 935 if (query->callback) { 936 head = (const struct nlattr *) nlmsg_data(nlh); 937 len = nlmsg_len(nlh); 938 switch (query->path_use) { 939 case LS_RESOLVE_PATH_USE_UNIDIRECTIONAL: 940 mask = IB_PATH_PRIMARY | IB_PATH_OUTBOUND; 941 break; 942 943 case LS_RESOLVE_PATH_USE_ALL: 944 case LS_RESOLVE_PATH_USE_GMP: 945 default: 946 mask = IB_PATH_PRIMARY | IB_PATH_GMP | 947 IB_PATH_BIDIRECTIONAL; 948 break; 949 } 950 nla_for_each_attr(curr, head, len, rem) { 951 if (curr->nla_type == LS_NLA_TYPE_PATH_RECORD) { 952 rec = nla_data(curr); 953 /* 954 * Get the first one. In the future, we may 955 * need to get up to 6 pathrecords. 956 */ 957 if ((rec->flags & mask) == mask) { 958 mad = query->mad_buf->mad; 959 mad->mad_hdr.method |= 960 IB_MGMT_METHOD_RESP; 961 memcpy(mad->data, rec->path_rec, 962 sizeof(rec->path_rec)); 963 status = 0; 964 break; 965 } 966 } 967 } 968 query->callback(query, status, mad); 969 } 970 971 mad_send_wc.send_buf = query->mad_buf; 972 mad_send_wc.status = IB_WC_SUCCESS; 973 send_handler(query->mad_buf->mad_agent, &mad_send_wc); 974 } 975 976 static void ib_nl_request_timeout(struct work_struct *work) 977 { 978 unsigned long flags; 979 struct ib_sa_query *query; 980 unsigned long delay; 981 struct ib_mad_send_wc mad_send_wc; 982 int ret; 983 984 spin_lock_irqsave(&ib_nl_request_lock, flags); 985 while (!list_empty(&ib_nl_request_list)) { 986 query = list_entry(ib_nl_request_list.next, 987 struct ib_sa_query, list); 988 989 if (time_after(query->timeout, jiffies)) { 990 delay = query->timeout - jiffies; 991 if ((long)delay <= 0) 992 delay = 1; 993 queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay); 994 break; 995 } 996 997 list_del(&query->list); 998 ib_sa_disable_local_svc(query); 999 /* Hold the lock to protect against query cancellation */ 1000 if (ib_sa_query_cancelled(query)) 1001 ret = -1; 1002 else 1003 ret = ib_post_send_mad(query->mad_buf, NULL); 1004 if (ret) { 1005 mad_send_wc.send_buf = query->mad_buf; 1006 mad_send_wc.status = IB_WC_WR_FLUSH_ERR; 1007 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1008 send_handler(query->port->agent, &mad_send_wc); 1009 spin_lock_irqsave(&ib_nl_request_lock, flags); 1010 } 1011 } 1012 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1013 } 1014 1015 int ib_nl_handle_set_timeout(struct sk_buff *skb, 1016 struct nlmsghdr *nlh, 1017 struct netlink_ext_ack *extack) 1018 { 1019 int timeout, delta, abs_delta; 1020 const struct nlattr *attr; 1021 unsigned long flags; 1022 struct ib_sa_query *query; 1023 long delay = 0; 1024 struct nlattr *tb[LS_NLA_TYPE_MAX]; 1025 int ret; 1026 1027 if (!(nlh->nlmsg_flags & NLM_F_REQUEST) || 1028 !(NETLINK_CB(skb).sk)) 1029 return -EPERM; 1030 1031 ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh), 1032 nlmsg_len(nlh), ib_nl_policy, NULL); 1033 attr = (const struct nlattr *)tb[LS_NLA_TYPE_TIMEOUT]; 1034 if (ret || !attr) 1035 goto settimeout_out; 1036 1037 timeout = *(int *) nla_data(attr); 1038 if (timeout < IB_SA_LOCAL_SVC_TIMEOUT_MIN) 1039 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MIN; 1040 if (timeout > IB_SA_LOCAL_SVC_TIMEOUT_MAX) 1041 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MAX; 1042 1043 delta = timeout - sa_local_svc_timeout_ms; 1044 if (delta < 0) 1045 abs_delta = -delta; 1046 else 1047 abs_delta = delta; 1048 1049 if (delta != 0) { 1050 spin_lock_irqsave(&ib_nl_request_lock, flags); 1051 sa_local_svc_timeout_ms = timeout; 1052 list_for_each_entry(query, &ib_nl_request_list, list) { 1053 if (delta < 0 && abs_delta > query->timeout) 1054 query->timeout = 0; 1055 else 1056 query->timeout += delta; 1057 1058 /* Get the new delay from the first entry */ 1059 if (!delay) { 1060 delay = query->timeout - jiffies; 1061 if (delay <= 0) 1062 delay = 1; 1063 } 1064 } 1065 if (delay) 1066 mod_delayed_work(ib_nl_wq, &ib_nl_timed_work, 1067 (unsigned long)delay); 1068 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1069 } 1070 1071 settimeout_out: 1072 return skb->len; 1073 } 1074 1075 static inline int ib_nl_is_good_resolve_resp(const struct nlmsghdr *nlh) 1076 { 1077 struct nlattr *tb[LS_NLA_TYPE_MAX]; 1078 int ret; 1079 1080 if (nlh->nlmsg_flags & RDMA_NL_LS_F_ERR) 1081 return 0; 1082 1083 ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh), 1084 nlmsg_len(nlh), ib_nl_policy, NULL); 1085 if (ret) 1086 return 0; 1087 1088 return 1; 1089 } 1090 1091 int ib_nl_handle_resolve_resp(struct sk_buff *skb, 1092 struct nlmsghdr *nlh, 1093 struct netlink_ext_ack *extack) 1094 { 1095 unsigned long flags; 1096 struct ib_sa_query *query; 1097 struct ib_mad_send_buf *send_buf; 1098 struct ib_mad_send_wc mad_send_wc; 1099 int found = 0; 1100 int ret; 1101 1102 if ((nlh->nlmsg_flags & NLM_F_REQUEST) || 1103 !(NETLINK_CB(skb).sk)) 1104 return -EPERM; 1105 1106 spin_lock_irqsave(&ib_nl_request_lock, flags); 1107 list_for_each_entry(query, &ib_nl_request_list, list) { 1108 /* 1109 * If the query is cancelled, let the timeout routine 1110 * take care of it. 1111 */ 1112 if (nlh->nlmsg_seq == query->seq) { 1113 found = !ib_sa_query_cancelled(query); 1114 if (found) 1115 list_del(&query->list); 1116 break; 1117 } 1118 } 1119 1120 if (!found) { 1121 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1122 goto resp_out; 1123 } 1124 1125 send_buf = query->mad_buf; 1126 1127 if (!ib_nl_is_good_resolve_resp(nlh)) { 1128 /* if the result is a failure, send out the packet via IB */ 1129 ib_sa_disable_local_svc(query); 1130 ret = ib_post_send_mad(query->mad_buf, NULL); 1131 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1132 if (ret) { 1133 mad_send_wc.send_buf = send_buf; 1134 mad_send_wc.status = IB_WC_GENERAL_ERR; 1135 send_handler(query->port->agent, &mad_send_wc); 1136 } 1137 } else { 1138 spin_unlock_irqrestore(&ib_nl_request_lock, flags); 1139 ib_nl_process_good_resolve_rsp(query, nlh); 1140 } 1141 1142 resp_out: 1143 return skb->len; 1144 } 1145 1146 static void free_sm_ah(struct kref *kref) 1147 { 1148 struct ib_sa_sm_ah *sm_ah = container_of(kref, struct ib_sa_sm_ah, ref); 1149 1150 rdma_destroy_ah(sm_ah->ah); 1151 kfree(sm_ah); 1152 } 1153 1154 void ib_sa_register_client(struct ib_sa_client *client) 1155 { 1156 atomic_set(&client->users, 1); 1157 init_completion(&client->comp); 1158 } 1159 EXPORT_SYMBOL(ib_sa_register_client); 1160 1161 void ib_sa_unregister_client(struct ib_sa_client *client) 1162 { 1163 ib_sa_client_put(client); 1164 wait_for_completion(&client->comp); 1165 } 1166 EXPORT_SYMBOL(ib_sa_unregister_client); 1167 1168 /** 1169 * ib_sa_cancel_query - try to cancel an SA query 1170 * @id:ID of query to cancel 1171 * @query:query pointer to cancel 1172 * 1173 * Try to cancel an SA query. If the id and query don't match up or 1174 * the query has already completed, nothing is done. Otherwise the 1175 * query is canceled and will complete with a status of -EINTR. 1176 */ 1177 void ib_sa_cancel_query(int id, struct ib_sa_query *query) 1178 { 1179 unsigned long flags; 1180 struct ib_mad_agent *agent; 1181 struct ib_mad_send_buf *mad_buf; 1182 1183 spin_lock_irqsave(&idr_lock, flags); 1184 if (idr_find(&query_idr, id) != query) { 1185 spin_unlock_irqrestore(&idr_lock, flags); 1186 return; 1187 } 1188 agent = query->port->agent; 1189 mad_buf = query->mad_buf; 1190 spin_unlock_irqrestore(&idr_lock, flags); 1191 1192 /* 1193 * If the query is still on the netlink request list, schedule 1194 * it to be cancelled by the timeout routine. Otherwise, it has been 1195 * sent to the MAD layer and has to be cancelled from there. 1196 */ 1197 if (!ib_nl_cancel_request(query)) 1198 ib_cancel_mad(agent, mad_buf); 1199 } 1200 EXPORT_SYMBOL(ib_sa_cancel_query); 1201 1202 static u8 get_src_path_mask(struct ib_device *device, u8 port_num) 1203 { 1204 struct ib_sa_device *sa_dev; 1205 struct ib_sa_port *port; 1206 unsigned long flags; 1207 u8 src_path_mask; 1208 1209 sa_dev = ib_get_client_data(device, &sa_client); 1210 if (!sa_dev) 1211 return 0x7f; 1212 1213 port = &sa_dev->port[port_num - sa_dev->start_port]; 1214 spin_lock_irqsave(&port->ah_lock, flags); 1215 src_path_mask = port->sm_ah ? port->sm_ah->src_path_mask : 0x7f; 1216 spin_unlock_irqrestore(&port->ah_lock, flags); 1217 1218 return src_path_mask; 1219 } 1220 1221 static int init_ah_attr_grh_fields(struct ib_device *device, u8 port_num, 1222 struct sa_path_rec *rec, 1223 struct rdma_ah_attr *ah_attr, 1224 const struct ib_gid_attr *gid_attr) 1225 { 1226 enum ib_gid_type type = sa_conv_pathrec_to_gid_type(rec); 1227 1228 if (!gid_attr) { 1229 gid_attr = rdma_find_gid_by_port(device, &rec->sgid, type, 1230 port_num, NULL); 1231 if (IS_ERR(gid_attr)) 1232 return PTR_ERR(gid_attr); 1233 } else 1234 rdma_hold_gid_attr(gid_attr); 1235 1236 rdma_move_grh_sgid_attr(ah_attr, &rec->dgid, 1237 be32_to_cpu(rec->flow_label), 1238 rec->hop_limit, rec->traffic_class, 1239 gid_attr); 1240 return 0; 1241 } 1242 1243 /** 1244 * ib_init_ah_attr_from_path - Initialize address handle attributes based on 1245 * an SA path record. 1246 * @device: Device associated ah attributes initialization. 1247 * @port_num: Port on the specified device. 1248 * @rec: path record entry to use for ah attributes initialization. 1249 * @ah_attr: address handle attributes to initialization from path record. 1250 * @sgid_attr: SGID attribute to consider during initialization. 1251 * 1252 * When ib_init_ah_attr_from_path() returns success, 1253 * (a) for IB link layer it optionally contains a reference to SGID attribute 1254 * when GRH is present for IB link layer. 1255 * (b) for RoCE link layer it contains a reference to SGID attribute. 1256 * User must invoke rdma_destroy_ah_attr() to release reference to SGID 1257 * attributes which are initialized using ib_init_ah_attr_from_path(). 1258 */ 1259 int ib_init_ah_attr_from_path(struct ib_device *device, u8 port_num, 1260 struct sa_path_rec *rec, 1261 struct rdma_ah_attr *ah_attr, 1262 const struct ib_gid_attr *gid_attr) 1263 { 1264 int ret = 0; 1265 1266 memset(ah_attr, 0, sizeof(*ah_attr)); 1267 ah_attr->type = rdma_ah_find_type(device, port_num); 1268 rdma_ah_set_sl(ah_attr, rec->sl); 1269 rdma_ah_set_port_num(ah_attr, port_num); 1270 rdma_ah_set_static_rate(ah_attr, rec->rate); 1271 1272 if (sa_path_is_roce(rec)) { 1273 ret = roce_resolve_route_from_path(rec, gid_attr); 1274 if (ret) 1275 return ret; 1276 1277 memcpy(ah_attr->roce.dmac, sa_path_get_dmac(rec), ETH_ALEN); 1278 } else { 1279 rdma_ah_set_dlid(ah_attr, be32_to_cpu(sa_path_get_dlid(rec))); 1280 if (sa_path_is_opa(rec) && 1281 rdma_ah_get_dlid(ah_attr) == be16_to_cpu(IB_LID_PERMISSIVE)) 1282 rdma_ah_set_make_grd(ah_attr, true); 1283 1284 rdma_ah_set_path_bits(ah_attr, 1285 be32_to_cpu(sa_path_get_slid(rec)) & 1286 get_src_path_mask(device, port_num)); 1287 } 1288 1289 if (rec->hop_limit > 0 || sa_path_is_roce(rec)) 1290 ret = init_ah_attr_grh_fields(device, port_num, 1291 rec, ah_attr, gid_attr); 1292 return ret; 1293 } 1294 EXPORT_SYMBOL(ib_init_ah_attr_from_path); 1295 1296 static int alloc_mad(struct ib_sa_query *query, gfp_t gfp_mask) 1297 { 1298 struct rdma_ah_attr ah_attr; 1299 unsigned long flags; 1300 1301 spin_lock_irqsave(&query->port->ah_lock, flags); 1302 if (!query->port->sm_ah) { 1303 spin_unlock_irqrestore(&query->port->ah_lock, flags); 1304 return -EAGAIN; 1305 } 1306 kref_get(&query->port->sm_ah->ref); 1307 query->sm_ah = query->port->sm_ah; 1308 spin_unlock_irqrestore(&query->port->ah_lock, flags); 1309 1310 /* 1311 * Always check if sm_ah has valid dlid assigned, 1312 * before querying for class port info 1313 */ 1314 if ((rdma_query_ah(query->sm_ah->ah, &ah_attr) < 0) || 1315 !rdma_is_valid_unicast_lid(&ah_attr)) { 1316 kref_put(&query->sm_ah->ref, free_sm_ah); 1317 return -EAGAIN; 1318 } 1319 query->mad_buf = ib_create_send_mad(query->port->agent, 1, 1320 query->sm_ah->pkey_index, 1321 0, IB_MGMT_SA_HDR, IB_MGMT_SA_DATA, 1322 gfp_mask, 1323 ((query->flags & IB_SA_QUERY_OPA) ? 1324 OPA_MGMT_BASE_VERSION : 1325 IB_MGMT_BASE_VERSION)); 1326 if (IS_ERR(query->mad_buf)) { 1327 kref_put(&query->sm_ah->ref, free_sm_ah); 1328 return -ENOMEM; 1329 } 1330 1331 query->mad_buf->ah = query->sm_ah->ah; 1332 1333 return 0; 1334 } 1335 1336 static void free_mad(struct ib_sa_query *query) 1337 { 1338 ib_free_send_mad(query->mad_buf); 1339 kref_put(&query->sm_ah->ref, free_sm_ah); 1340 } 1341 1342 static void init_mad(struct ib_sa_query *query, struct ib_mad_agent *agent) 1343 { 1344 struct ib_sa_mad *mad = query->mad_buf->mad; 1345 unsigned long flags; 1346 1347 memset(mad, 0, sizeof *mad); 1348 1349 if (query->flags & IB_SA_QUERY_OPA) { 1350 mad->mad_hdr.base_version = OPA_MGMT_BASE_VERSION; 1351 mad->mad_hdr.class_version = OPA_SA_CLASS_VERSION; 1352 } else { 1353 mad->mad_hdr.base_version = IB_MGMT_BASE_VERSION; 1354 mad->mad_hdr.class_version = IB_SA_CLASS_VERSION; 1355 } 1356 mad->mad_hdr.mgmt_class = IB_MGMT_CLASS_SUBN_ADM; 1357 spin_lock_irqsave(&tid_lock, flags); 1358 mad->mad_hdr.tid = 1359 cpu_to_be64(((u64) agent->hi_tid) << 32 | tid++); 1360 spin_unlock_irqrestore(&tid_lock, flags); 1361 } 1362 1363 static int send_mad(struct ib_sa_query *query, unsigned long timeout_ms, 1364 gfp_t gfp_mask) 1365 { 1366 bool preload = gfpflags_allow_blocking(gfp_mask); 1367 unsigned long flags; 1368 int ret, id; 1369 1370 if (preload) 1371 idr_preload(gfp_mask); 1372 spin_lock_irqsave(&idr_lock, flags); 1373 1374 id = idr_alloc(&query_idr, query, 0, 0, GFP_NOWAIT); 1375 1376 spin_unlock_irqrestore(&idr_lock, flags); 1377 if (preload) 1378 idr_preload_end(); 1379 if (id < 0) 1380 return id; 1381 1382 query->mad_buf->timeout_ms = timeout_ms; 1383 query->mad_buf->context[0] = query; 1384 query->id = id; 1385 1386 if ((query->flags & IB_SA_ENABLE_LOCAL_SERVICE) && 1387 (!(query->flags & IB_SA_QUERY_OPA))) { 1388 if (rdma_nl_chk_listeners(RDMA_NL_GROUP_LS)) { 1389 if (!ib_nl_make_request(query, gfp_mask)) 1390 return id; 1391 } 1392 ib_sa_disable_local_svc(query); 1393 } 1394 1395 ret = ib_post_send_mad(query->mad_buf, NULL); 1396 if (ret) { 1397 spin_lock_irqsave(&idr_lock, flags); 1398 idr_remove(&query_idr, id); 1399 spin_unlock_irqrestore(&idr_lock, flags); 1400 } 1401 1402 /* 1403 * It's not safe to dereference query any more, because the 1404 * send may already have completed and freed the query in 1405 * another context. 1406 */ 1407 return ret ? ret : id; 1408 } 1409 1410 void ib_sa_unpack_path(void *attribute, struct sa_path_rec *rec) 1411 { 1412 ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table), attribute, rec); 1413 } 1414 EXPORT_SYMBOL(ib_sa_unpack_path); 1415 1416 void ib_sa_pack_path(struct sa_path_rec *rec, void *attribute) 1417 { 1418 ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, attribute); 1419 } 1420 EXPORT_SYMBOL(ib_sa_pack_path); 1421 1422 static bool ib_sa_opa_pathrecord_support(struct ib_sa_client *client, 1423 struct ib_device *device, 1424 u8 port_num) 1425 { 1426 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1427 struct ib_sa_port *port; 1428 unsigned long flags; 1429 bool ret = false; 1430 1431 if (!sa_dev) 1432 return ret; 1433 1434 port = &sa_dev->port[port_num - sa_dev->start_port]; 1435 spin_lock_irqsave(&port->classport_lock, flags); 1436 if (!port->classport_info.valid) 1437 goto ret; 1438 1439 if (port->classport_info.data.type == RDMA_CLASS_PORT_INFO_OPA) 1440 ret = opa_get_cpi_capmask2(&port->classport_info.data.opa) & 1441 OPA_CLASS_PORT_INFO_PR_SUPPORT; 1442 ret: 1443 spin_unlock_irqrestore(&port->classport_lock, flags); 1444 return ret; 1445 } 1446 1447 enum opa_pr_supported { 1448 PR_NOT_SUPPORTED, 1449 PR_OPA_SUPPORTED, 1450 PR_IB_SUPPORTED 1451 }; 1452 1453 /** 1454 * Check if current PR query can be an OPA query. 1455 * Retuns PR_NOT_SUPPORTED if a path record query is not 1456 * possible, PR_OPA_SUPPORTED if an OPA path record query 1457 * is possible and PR_IB_SUPPORTED if an IB path record 1458 * query is possible. 1459 */ 1460 static int opa_pr_query_possible(struct ib_sa_client *client, 1461 struct ib_device *device, 1462 u8 port_num, 1463 struct sa_path_rec *rec) 1464 { 1465 struct ib_port_attr port_attr; 1466 1467 if (ib_query_port(device, port_num, &port_attr)) 1468 return PR_NOT_SUPPORTED; 1469 1470 if (ib_sa_opa_pathrecord_support(client, device, port_num)) 1471 return PR_OPA_SUPPORTED; 1472 1473 if (port_attr.lid >= be16_to_cpu(IB_MULTICAST_LID_BASE)) 1474 return PR_NOT_SUPPORTED; 1475 else 1476 return PR_IB_SUPPORTED; 1477 } 1478 1479 static void ib_sa_path_rec_callback(struct ib_sa_query *sa_query, 1480 int status, 1481 struct ib_sa_mad *mad) 1482 { 1483 struct ib_sa_path_query *query = 1484 container_of(sa_query, struct ib_sa_path_query, sa_query); 1485 1486 if (mad) { 1487 struct sa_path_rec rec; 1488 1489 if (sa_query->flags & IB_SA_QUERY_OPA) { 1490 ib_unpack(opa_path_rec_table, 1491 ARRAY_SIZE(opa_path_rec_table), 1492 mad->data, &rec); 1493 rec.rec_type = SA_PATH_REC_TYPE_OPA; 1494 query->callback(status, &rec, query->context); 1495 } else { 1496 ib_unpack(path_rec_table, 1497 ARRAY_SIZE(path_rec_table), 1498 mad->data, &rec); 1499 rec.rec_type = SA_PATH_REC_TYPE_IB; 1500 sa_path_set_dmac_zero(&rec); 1501 1502 if (query->conv_pr) { 1503 struct sa_path_rec opa; 1504 1505 memset(&opa, 0, sizeof(struct sa_path_rec)); 1506 sa_convert_path_ib_to_opa(&opa, &rec); 1507 query->callback(status, &opa, query->context); 1508 } else { 1509 query->callback(status, &rec, query->context); 1510 } 1511 } 1512 } else 1513 query->callback(status, NULL, query->context); 1514 } 1515 1516 static void ib_sa_path_rec_release(struct ib_sa_query *sa_query) 1517 { 1518 struct ib_sa_path_query *query = 1519 container_of(sa_query, struct ib_sa_path_query, sa_query); 1520 1521 kfree(query->conv_pr); 1522 kfree(query); 1523 } 1524 1525 /** 1526 * ib_sa_path_rec_get - Start a Path get query 1527 * @client:SA client 1528 * @device:device to send query on 1529 * @port_num: port number to send query on 1530 * @rec:Path Record to send in query 1531 * @comp_mask:component mask to send in query 1532 * @timeout_ms:time to wait for response 1533 * @gfp_mask:GFP mask to use for internal allocations 1534 * @callback:function called when query completes, times out or is 1535 * canceled 1536 * @context:opaque user context passed to callback 1537 * @sa_query:query context, used to cancel query 1538 * 1539 * Send a Path Record Get query to the SA to look up a path. The 1540 * callback function will be called when the query completes (or 1541 * fails); status is 0 for a successful response, -EINTR if the query 1542 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error 1543 * occurred sending the query. The resp parameter of the callback is 1544 * only valid if status is 0. 1545 * 1546 * If the return value of ib_sa_path_rec_get() is negative, it is an 1547 * error code. Otherwise it is a query ID that can be used to cancel 1548 * the query. 1549 */ 1550 int ib_sa_path_rec_get(struct ib_sa_client *client, 1551 struct ib_device *device, u8 port_num, 1552 struct sa_path_rec *rec, 1553 ib_sa_comp_mask comp_mask, 1554 unsigned long timeout_ms, gfp_t gfp_mask, 1555 void (*callback)(int status, 1556 struct sa_path_rec *resp, 1557 void *context), 1558 void *context, 1559 struct ib_sa_query **sa_query) 1560 { 1561 struct ib_sa_path_query *query; 1562 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1563 struct ib_sa_port *port; 1564 struct ib_mad_agent *agent; 1565 struct ib_sa_mad *mad; 1566 enum opa_pr_supported status; 1567 int ret; 1568 1569 if (!sa_dev) 1570 return -ENODEV; 1571 1572 if ((rec->rec_type != SA_PATH_REC_TYPE_IB) && 1573 (rec->rec_type != SA_PATH_REC_TYPE_OPA)) 1574 return -EINVAL; 1575 1576 port = &sa_dev->port[port_num - sa_dev->start_port]; 1577 agent = port->agent; 1578 1579 query = kzalloc(sizeof(*query), gfp_mask); 1580 if (!query) 1581 return -ENOMEM; 1582 1583 query->sa_query.port = port; 1584 if (rec->rec_type == SA_PATH_REC_TYPE_OPA) { 1585 status = opa_pr_query_possible(client, device, port_num, rec); 1586 if (status == PR_NOT_SUPPORTED) { 1587 ret = -EINVAL; 1588 goto err1; 1589 } else if (status == PR_OPA_SUPPORTED) { 1590 query->sa_query.flags |= IB_SA_QUERY_OPA; 1591 } else { 1592 query->conv_pr = 1593 kmalloc(sizeof(*query->conv_pr), gfp_mask); 1594 if (!query->conv_pr) { 1595 ret = -ENOMEM; 1596 goto err1; 1597 } 1598 } 1599 } 1600 1601 ret = alloc_mad(&query->sa_query, gfp_mask); 1602 if (ret) 1603 goto err2; 1604 1605 ib_sa_client_get(client); 1606 query->sa_query.client = client; 1607 query->callback = callback; 1608 query->context = context; 1609 1610 mad = query->sa_query.mad_buf->mad; 1611 init_mad(&query->sa_query, agent); 1612 1613 query->sa_query.callback = callback ? ib_sa_path_rec_callback : NULL; 1614 query->sa_query.release = ib_sa_path_rec_release; 1615 mad->mad_hdr.method = IB_MGMT_METHOD_GET; 1616 mad->mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_PATH_REC); 1617 mad->sa_hdr.comp_mask = comp_mask; 1618 1619 if (query->sa_query.flags & IB_SA_QUERY_OPA) { 1620 ib_pack(opa_path_rec_table, ARRAY_SIZE(opa_path_rec_table), 1621 rec, mad->data); 1622 } else if (query->conv_pr) { 1623 sa_convert_path_opa_to_ib(query->conv_pr, rec); 1624 ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), 1625 query->conv_pr, mad->data); 1626 } else { 1627 ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), 1628 rec, mad->data); 1629 } 1630 1631 *sa_query = &query->sa_query; 1632 1633 query->sa_query.flags |= IB_SA_ENABLE_LOCAL_SERVICE; 1634 query->sa_query.mad_buf->context[1] = (query->conv_pr) ? 1635 query->conv_pr : rec; 1636 1637 ret = send_mad(&query->sa_query, timeout_ms, gfp_mask); 1638 if (ret < 0) 1639 goto err3; 1640 1641 return ret; 1642 1643 err3: 1644 *sa_query = NULL; 1645 ib_sa_client_put(query->sa_query.client); 1646 free_mad(&query->sa_query); 1647 err2: 1648 kfree(query->conv_pr); 1649 err1: 1650 kfree(query); 1651 return ret; 1652 } 1653 EXPORT_SYMBOL(ib_sa_path_rec_get); 1654 1655 static void ib_sa_service_rec_callback(struct ib_sa_query *sa_query, 1656 int status, 1657 struct ib_sa_mad *mad) 1658 { 1659 struct ib_sa_service_query *query = 1660 container_of(sa_query, struct ib_sa_service_query, sa_query); 1661 1662 if (mad) { 1663 struct ib_sa_service_rec rec; 1664 1665 ib_unpack(service_rec_table, ARRAY_SIZE(service_rec_table), 1666 mad->data, &rec); 1667 query->callback(status, &rec, query->context); 1668 } else 1669 query->callback(status, NULL, query->context); 1670 } 1671 1672 static void ib_sa_service_rec_release(struct ib_sa_query *sa_query) 1673 { 1674 kfree(container_of(sa_query, struct ib_sa_service_query, sa_query)); 1675 } 1676 1677 /** 1678 * ib_sa_service_rec_query - Start Service Record operation 1679 * @client:SA client 1680 * @device:device to send request on 1681 * @port_num: port number to send request on 1682 * @method:SA method - should be get, set, or delete 1683 * @rec:Service Record to send in request 1684 * @comp_mask:component mask to send in request 1685 * @timeout_ms:time to wait for response 1686 * @gfp_mask:GFP mask to use for internal allocations 1687 * @callback:function called when request completes, times out or is 1688 * canceled 1689 * @context:opaque user context passed to callback 1690 * @sa_query:request context, used to cancel request 1691 * 1692 * Send a Service Record set/get/delete to the SA to register, 1693 * unregister or query a service record. 1694 * The callback function will be called when the request completes (or 1695 * fails); status is 0 for a successful response, -EINTR if the query 1696 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error 1697 * occurred sending the query. The resp parameter of the callback is 1698 * only valid if status is 0. 1699 * 1700 * If the return value of ib_sa_service_rec_query() is negative, it is an 1701 * error code. Otherwise it is a request ID that can be used to cancel 1702 * the query. 1703 */ 1704 int ib_sa_service_rec_query(struct ib_sa_client *client, 1705 struct ib_device *device, u8 port_num, u8 method, 1706 struct ib_sa_service_rec *rec, 1707 ib_sa_comp_mask comp_mask, 1708 unsigned long timeout_ms, gfp_t gfp_mask, 1709 void (*callback)(int status, 1710 struct ib_sa_service_rec *resp, 1711 void *context), 1712 void *context, 1713 struct ib_sa_query **sa_query) 1714 { 1715 struct ib_sa_service_query *query; 1716 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1717 struct ib_sa_port *port; 1718 struct ib_mad_agent *agent; 1719 struct ib_sa_mad *mad; 1720 int ret; 1721 1722 if (!sa_dev) 1723 return -ENODEV; 1724 1725 port = &sa_dev->port[port_num - sa_dev->start_port]; 1726 agent = port->agent; 1727 1728 if (method != IB_MGMT_METHOD_GET && 1729 method != IB_MGMT_METHOD_SET && 1730 method != IB_SA_METHOD_DELETE) 1731 return -EINVAL; 1732 1733 query = kzalloc(sizeof(*query), gfp_mask); 1734 if (!query) 1735 return -ENOMEM; 1736 1737 query->sa_query.port = port; 1738 ret = alloc_mad(&query->sa_query, gfp_mask); 1739 if (ret) 1740 goto err1; 1741 1742 ib_sa_client_get(client); 1743 query->sa_query.client = client; 1744 query->callback = callback; 1745 query->context = context; 1746 1747 mad = query->sa_query.mad_buf->mad; 1748 init_mad(&query->sa_query, agent); 1749 1750 query->sa_query.callback = callback ? ib_sa_service_rec_callback : NULL; 1751 query->sa_query.release = ib_sa_service_rec_release; 1752 mad->mad_hdr.method = method; 1753 mad->mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_SERVICE_REC); 1754 mad->sa_hdr.comp_mask = comp_mask; 1755 1756 ib_pack(service_rec_table, ARRAY_SIZE(service_rec_table), 1757 rec, mad->data); 1758 1759 *sa_query = &query->sa_query; 1760 1761 ret = send_mad(&query->sa_query, timeout_ms, gfp_mask); 1762 if (ret < 0) 1763 goto err2; 1764 1765 return ret; 1766 1767 err2: 1768 *sa_query = NULL; 1769 ib_sa_client_put(query->sa_query.client); 1770 free_mad(&query->sa_query); 1771 1772 err1: 1773 kfree(query); 1774 return ret; 1775 } 1776 EXPORT_SYMBOL(ib_sa_service_rec_query); 1777 1778 static void ib_sa_mcmember_rec_callback(struct ib_sa_query *sa_query, 1779 int status, 1780 struct ib_sa_mad *mad) 1781 { 1782 struct ib_sa_mcmember_query *query = 1783 container_of(sa_query, struct ib_sa_mcmember_query, sa_query); 1784 1785 if (mad) { 1786 struct ib_sa_mcmember_rec rec; 1787 1788 ib_unpack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table), 1789 mad->data, &rec); 1790 query->callback(status, &rec, query->context); 1791 } else 1792 query->callback(status, NULL, query->context); 1793 } 1794 1795 static void ib_sa_mcmember_rec_release(struct ib_sa_query *sa_query) 1796 { 1797 kfree(container_of(sa_query, struct ib_sa_mcmember_query, sa_query)); 1798 } 1799 1800 int ib_sa_mcmember_rec_query(struct ib_sa_client *client, 1801 struct ib_device *device, u8 port_num, 1802 u8 method, 1803 struct ib_sa_mcmember_rec *rec, 1804 ib_sa_comp_mask comp_mask, 1805 unsigned long timeout_ms, gfp_t gfp_mask, 1806 void (*callback)(int status, 1807 struct ib_sa_mcmember_rec *resp, 1808 void *context), 1809 void *context, 1810 struct ib_sa_query **sa_query) 1811 { 1812 struct ib_sa_mcmember_query *query; 1813 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1814 struct ib_sa_port *port; 1815 struct ib_mad_agent *agent; 1816 struct ib_sa_mad *mad; 1817 int ret; 1818 1819 if (!sa_dev) 1820 return -ENODEV; 1821 1822 port = &sa_dev->port[port_num - sa_dev->start_port]; 1823 agent = port->agent; 1824 1825 query = kzalloc(sizeof(*query), gfp_mask); 1826 if (!query) 1827 return -ENOMEM; 1828 1829 query->sa_query.port = port; 1830 ret = alloc_mad(&query->sa_query, gfp_mask); 1831 if (ret) 1832 goto err1; 1833 1834 ib_sa_client_get(client); 1835 query->sa_query.client = client; 1836 query->callback = callback; 1837 query->context = context; 1838 1839 mad = query->sa_query.mad_buf->mad; 1840 init_mad(&query->sa_query, agent); 1841 1842 query->sa_query.callback = callback ? ib_sa_mcmember_rec_callback : NULL; 1843 query->sa_query.release = ib_sa_mcmember_rec_release; 1844 mad->mad_hdr.method = method; 1845 mad->mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC); 1846 mad->sa_hdr.comp_mask = comp_mask; 1847 1848 ib_pack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table), 1849 rec, mad->data); 1850 1851 *sa_query = &query->sa_query; 1852 1853 ret = send_mad(&query->sa_query, timeout_ms, gfp_mask); 1854 if (ret < 0) 1855 goto err2; 1856 1857 return ret; 1858 1859 err2: 1860 *sa_query = NULL; 1861 ib_sa_client_put(query->sa_query.client); 1862 free_mad(&query->sa_query); 1863 1864 err1: 1865 kfree(query); 1866 return ret; 1867 } 1868 1869 /* Support GuidInfoRecord */ 1870 static void ib_sa_guidinfo_rec_callback(struct ib_sa_query *sa_query, 1871 int status, 1872 struct ib_sa_mad *mad) 1873 { 1874 struct ib_sa_guidinfo_query *query = 1875 container_of(sa_query, struct ib_sa_guidinfo_query, sa_query); 1876 1877 if (mad) { 1878 struct ib_sa_guidinfo_rec rec; 1879 1880 ib_unpack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table), 1881 mad->data, &rec); 1882 query->callback(status, &rec, query->context); 1883 } else 1884 query->callback(status, NULL, query->context); 1885 } 1886 1887 static void ib_sa_guidinfo_rec_release(struct ib_sa_query *sa_query) 1888 { 1889 kfree(container_of(sa_query, struct ib_sa_guidinfo_query, sa_query)); 1890 } 1891 1892 int ib_sa_guid_info_rec_query(struct ib_sa_client *client, 1893 struct ib_device *device, u8 port_num, 1894 struct ib_sa_guidinfo_rec *rec, 1895 ib_sa_comp_mask comp_mask, u8 method, 1896 unsigned long timeout_ms, gfp_t gfp_mask, 1897 void (*callback)(int status, 1898 struct ib_sa_guidinfo_rec *resp, 1899 void *context), 1900 void *context, 1901 struct ib_sa_query **sa_query) 1902 { 1903 struct ib_sa_guidinfo_query *query; 1904 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1905 struct ib_sa_port *port; 1906 struct ib_mad_agent *agent; 1907 struct ib_sa_mad *mad; 1908 int ret; 1909 1910 if (!sa_dev) 1911 return -ENODEV; 1912 1913 if (method != IB_MGMT_METHOD_GET && 1914 method != IB_MGMT_METHOD_SET && 1915 method != IB_SA_METHOD_DELETE) { 1916 return -EINVAL; 1917 } 1918 1919 port = &sa_dev->port[port_num - sa_dev->start_port]; 1920 agent = port->agent; 1921 1922 query = kzalloc(sizeof(*query), gfp_mask); 1923 if (!query) 1924 return -ENOMEM; 1925 1926 query->sa_query.port = port; 1927 ret = alloc_mad(&query->sa_query, gfp_mask); 1928 if (ret) 1929 goto err1; 1930 1931 ib_sa_client_get(client); 1932 query->sa_query.client = client; 1933 query->callback = callback; 1934 query->context = context; 1935 1936 mad = query->sa_query.mad_buf->mad; 1937 init_mad(&query->sa_query, agent); 1938 1939 query->sa_query.callback = callback ? ib_sa_guidinfo_rec_callback : NULL; 1940 query->sa_query.release = ib_sa_guidinfo_rec_release; 1941 1942 mad->mad_hdr.method = method; 1943 mad->mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_GUID_INFO_REC); 1944 mad->sa_hdr.comp_mask = comp_mask; 1945 1946 ib_pack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table), rec, 1947 mad->data); 1948 1949 *sa_query = &query->sa_query; 1950 1951 ret = send_mad(&query->sa_query, timeout_ms, gfp_mask); 1952 if (ret < 0) 1953 goto err2; 1954 1955 return ret; 1956 1957 err2: 1958 *sa_query = NULL; 1959 ib_sa_client_put(query->sa_query.client); 1960 free_mad(&query->sa_query); 1961 1962 err1: 1963 kfree(query); 1964 return ret; 1965 } 1966 EXPORT_SYMBOL(ib_sa_guid_info_rec_query); 1967 1968 bool ib_sa_sendonly_fullmem_support(struct ib_sa_client *client, 1969 struct ib_device *device, 1970 u8 port_num) 1971 { 1972 struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client); 1973 struct ib_sa_port *port; 1974 bool ret = false; 1975 unsigned long flags; 1976 1977 if (!sa_dev) 1978 return ret; 1979 1980 port = &sa_dev->port[port_num - sa_dev->start_port]; 1981 1982 spin_lock_irqsave(&port->classport_lock, flags); 1983 if ((port->classport_info.valid) && 1984 (port->classport_info.data.type == RDMA_CLASS_PORT_INFO_IB)) 1985 ret = ib_get_cpi_capmask2(&port->classport_info.data.ib) 1986 & IB_SA_CAP_MASK2_SENDONLY_FULL_MEM_SUPPORT; 1987 spin_unlock_irqrestore(&port->classport_lock, flags); 1988 return ret; 1989 } 1990 EXPORT_SYMBOL(ib_sa_sendonly_fullmem_support); 1991 1992 struct ib_classport_info_context { 1993 struct completion done; 1994 struct ib_sa_query *sa_query; 1995 }; 1996 1997 static void ib_classportinfo_cb(void *context) 1998 { 1999 struct ib_classport_info_context *cb_ctx = context; 2000 2001 complete(&cb_ctx->done); 2002 } 2003 2004 static void ib_sa_classport_info_rec_callback(struct ib_sa_query *sa_query, 2005 int status, 2006 struct ib_sa_mad *mad) 2007 { 2008 unsigned long flags; 2009 struct ib_sa_classport_info_query *query = 2010 container_of(sa_query, struct ib_sa_classport_info_query, sa_query); 2011 struct ib_sa_classport_cache *info = &sa_query->port->classport_info; 2012 2013 if (mad) { 2014 if (sa_query->flags & IB_SA_QUERY_OPA) { 2015 struct opa_class_port_info rec; 2016 2017 ib_unpack(opa_classport_info_rec_table, 2018 ARRAY_SIZE(opa_classport_info_rec_table), 2019 mad->data, &rec); 2020 2021 spin_lock_irqsave(&sa_query->port->classport_lock, 2022 flags); 2023 if (!status && !info->valid) { 2024 memcpy(&info->data.opa, &rec, 2025 sizeof(info->data.opa)); 2026 2027 info->valid = true; 2028 info->data.type = RDMA_CLASS_PORT_INFO_OPA; 2029 } 2030 spin_unlock_irqrestore(&sa_query->port->classport_lock, 2031 flags); 2032 2033 } else { 2034 struct ib_class_port_info rec; 2035 2036 ib_unpack(ib_classport_info_rec_table, 2037 ARRAY_SIZE(ib_classport_info_rec_table), 2038 mad->data, &rec); 2039 2040 spin_lock_irqsave(&sa_query->port->classport_lock, 2041 flags); 2042 if (!status && !info->valid) { 2043 memcpy(&info->data.ib, &rec, 2044 sizeof(info->data.ib)); 2045 2046 info->valid = true; 2047 info->data.type = RDMA_CLASS_PORT_INFO_IB; 2048 } 2049 spin_unlock_irqrestore(&sa_query->port->classport_lock, 2050 flags); 2051 } 2052 } 2053 query->callback(query->context); 2054 } 2055 2056 static void ib_sa_classport_info_rec_release(struct ib_sa_query *sa_query) 2057 { 2058 kfree(container_of(sa_query, struct ib_sa_classport_info_query, 2059 sa_query)); 2060 } 2061 2062 static int ib_sa_classport_info_rec_query(struct ib_sa_port *port, 2063 unsigned long timeout_ms, 2064 void (*callback)(void *context), 2065 void *context, 2066 struct ib_sa_query **sa_query) 2067 { 2068 struct ib_mad_agent *agent; 2069 struct ib_sa_classport_info_query *query; 2070 struct ib_sa_mad *mad; 2071 gfp_t gfp_mask = GFP_KERNEL; 2072 int ret; 2073 2074 agent = port->agent; 2075 2076 query = kzalloc(sizeof(*query), gfp_mask); 2077 if (!query) 2078 return -ENOMEM; 2079 2080 query->sa_query.port = port; 2081 query->sa_query.flags |= rdma_cap_opa_ah(port->agent->device, 2082 port->port_num) ? 2083 IB_SA_QUERY_OPA : 0; 2084 ret = alloc_mad(&query->sa_query, gfp_mask); 2085 if (ret) 2086 goto err_free; 2087 2088 query->callback = callback; 2089 query->context = context; 2090 2091 mad = query->sa_query.mad_buf->mad; 2092 init_mad(&query->sa_query, agent); 2093 2094 query->sa_query.callback = ib_sa_classport_info_rec_callback; 2095 query->sa_query.release = ib_sa_classport_info_rec_release; 2096 mad->mad_hdr.method = IB_MGMT_METHOD_GET; 2097 mad->mad_hdr.attr_id = cpu_to_be16(IB_SA_ATTR_CLASS_PORTINFO); 2098 mad->sa_hdr.comp_mask = 0; 2099 *sa_query = &query->sa_query; 2100 2101 ret = send_mad(&query->sa_query, timeout_ms, gfp_mask); 2102 if (ret < 0) 2103 goto err_free_mad; 2104 2105 return ret; 2106 2107 err_free_mad: 2108 *sa_query = NULL; 2109 free_mad(&query->sa_query); 2110 2111 err_free: 2112 kfree(query); 2113 return ret; 2114 } 2115 2116 static void update_ib_cpi(struct work_struct *work) 2117 { 2118 struct ib_sa_port *port = 2119 container_of(work, struct ib_sa_port, ib_cpi_work.work); 2120 struct ib_classport_info_context *cb_context; 2121 unsigned long flags; 2122 int ret; 2123 2124 /* If the classport info is valid, nothing 2125 * to do here. 2126 */ 2127 spin_lock_irqsave(&port->classport_lock, flags); 2128 if (port->classport_info.valid) { 2129 spin_unlock_irqrestore(&port->classport_lock, flags); 2130 return; 2131 } 2132 spin_unlock_irqrestore(&port->classport_lock, flags); 2133 2134 cb_context = kmalloc(sizeof(*cb_context), GFP_KERNEL); 2135 if (!cb_context) 2136 goto err_nomem; 2137 2138 init_completion(&cb_context->done); 2139 2140 ret = ib_sa_classport_info_rec_query(port, 3000, 2141 ib_classportinfo_cb, cb_context, 2142 &cb_context->sa_query); 2143 if (ret < 0) 2144 goto free_cb_err; 2145 wait_for_completion(&cb_context->done); 2146 free_cb_err: 2147 kfree(cb_context); 2148 spin_lock_irqsave(&port->classport_lock, flags); 2149 2150 /* If the classport info is still not valid, the query should have 2151 * failed for some reason. Retry issuing the query 2152 */ 2153 if (!port->classport_info.valid) { 2154 port->classport_info.retry_cnt++; 2155 if (port->classport_info.retry_cnt <= 2156 IB_SA_CPI_MAX_RETRY_CNT) { 2157 unsigned long delay = 2158 msecs_to_jiffies(IB_SA_CPI_RETRY_WAIT); 2159 2160 queue_delayed_work(ib_wq, &port->ib_cpi_work, delay); 2161 } 2162 } 2163 spin_unlock_irqrestore(&port->classport_lock, flags); 2164 2165 err_nomem: 2166 return; 2167 } 2168 2169 static void send_handler(struct ib_mad_agent *agent, 2170 struct ib_mad_send_wc *mad_send_wc) 2171 { 2172 struct ib_sa_query *query = mad_send_wc->send_buf->context[0]; 2173 unsigned long flags; 2174 2175 if (query->callback) 2176 switch (mad_send_wc->status) { 2177 case IB_WC_SUCCESS: 2178 /* No callback -- already got recv */ 2179 break; 2180 case IB_WC_RESP_TIMEOUT_ERR: 2181 query->callback(query, -ETIMEDOUT, NULL); 2182 break; 2183 case IB_WC_WR_FLUSH_ERR: 2184 query->callback(query, -EINTR, NULL); 2185 break; 2186 default: 2187 query->callback(query, -EIO, NULL); 2188 break; 2189 } 2190 2191 spin_lock_irqsave(&idr_lock, flags); 2192 idr_remove(&query_idr, query->id); 2193 spin_unlock_irqrestore(&idr_lock, flags); 2194 2195 free_mad(query); 2196 if (query->client) 2197 ib_sa_client_put(query->client); 2198 query->release(query); 2199 } 2200 2201 static void recv_handler(struct ib_mad_agent *mad_agent, 2202 struct ib_mad_send_buf *send_buf, 2203 struct ib_mad_recv_wc *mad_recv_wc) 2204 { 2205 struct ib_sa_query *query; 2206 2207 if (!send_buf) 2208 return; 2209 2210 query = send_buf->context[0]; 2211 if (query->callback) { 2212 if (mad_recv_wc->wc->status == IB_WC_SUCCESS) 2213 query->callback(query, 2214 mad_recv_wc->recv_buf.mad->mad_hdr.status ? 2215 -EINVAL : 0, 2216 (struct ib_sa_mad *) mad_recv_wc->recv_buf.mad); 2217 else 2218 query->callback(query, -EIO, NULL); 2219 } 2220 2221 ib_free_recv_mad(mad_recv_wc); 2222 } 2223 2224 static void update_sm_ah(struct work_struct *work) 2225 { 2226 struct ib_sa_port *port = 2227 container_of(work, struct ib_sa_port, update_task); 2228 struct ib_sa_sm_ah *new_ah; 2229 struct ib_port_attr port_attr; 2230 struct rdma_ah_attr ah_attr; 2231 bool grh_required; 2232 2233 if (ib_query_port(port->agent->device, port->port_num, &port_attr)) { 2234 pr_warn("Couldn't query port\n"); 2235 return; 2236 } 2237 2238 new_ah = kmalloc(sizeof(*new_ah), GFP_KERNEL); 2239 if (!new_ah) 2240 return; 2241 2242 kref_init(&new_ah->ref); 2243 new_ah->src_path_mask = (1 << port_attr.lmc) - 1; 2244 2245 new_ah->pkey_index = 0; 2246 if (ib_find_pkey(port->agent->device, port->port_num, 2247 IB_DEFAULT_PKEY_FULL, &new_ah->pkey_index)) 2248 pr_err("Couldn't find index for default PKey\n"); 2249 2250 memset(&ah_attr, 0, sizeof(ah_attr)); 2251 ah_attr.type = rdma_ah_find_type(port->agent->device, 2252 port->port_num); 2253 rdma_ah_set_dlid(&ah_attr, port_attr.sm_lid); 2254 rdma_ah_set_sl(&ah_attr, port_attr.sm_sl); 2255 rdma_ah_set_port_num(&ah_attr, port->port_num); 2256 2257 grh_required = rdma_is_grh_required(port->agent->device, 2258 port->port_num); 2259 2260 /* 2261 * The OPA sm_lid of 0xFFFF needs special handling so that it can be 2262 * differentiated from a permissive LID of 0xFFFF. We set the 2263 * grh_required flag here so the SA can program the DGID in the 2264 * address handle appropriately 2265 */ 2266 if (ah_attr.type == RDMA_AH_ATTR_TYPE_OPA && 2267 (grh_required || 2268 port_attr.sm_lid == be16_to_cpu(IB_LID_PERMISSIVE))) 2269 rdma_ah_set_make_grd(&ah_attr, true); 2270 2271 if (ah_attr.type == RDMA_AH_ATTR_TYPE_IB && grh_required) { 2272 rdma_ah_set_ah_flags(&ah_attr, IB_AH_GRH); 2273 rdma_ah_set_subnet_prefix(&ah_attr, 2274 cpu_to_be64(port_attr.subnet_prefix)); 2275 rdma_ah_set_interface_id(&ah_attr, 2276 cpu_to_be64(IB_SA_WELL_KNOWN_GUID)); 2277 } 2278 2279 new_ah->ah = rdma_create_ah(port->agent->qp->pd, &ah_attr); 2280 if (IS_ERR(new_ah->ah)) { 2281 pr_warn("Couldn't create new SM AH\n"); 2282 kfree(new_ah); 2283 return; 2284 } 2285 2286 spin_lock_irq(&port->ah_lock); 2287 if (port->sm_ah) 2288 kref_put(&port->sm_ah->ref, free_sm_ah); 2289 port->sm_ah = new_ah; 2290 spin_unlock_irq(&port->ah_lock); 2291 } 2292 2293 static void ib_sa_event(struct ib_event_handler *handler, 2294 struct ib_event *event) 2295 { 2296 if (event->event == IB_EVENT_PORT_ERR || 2297 event->event == IB_EVENT_PORT_ACTIVE || 2298 event->event == IB_EVENT_LID_CHANGE || 2299 event->event == IB_EVENT_PKEY_CHANGE || 2300 event->event == IB_EVENT_SM_CHANGE || 2301 event->event == IB_EVENT_CLIENT_REREGISTER) { 2302 unsigned long flags; 2303 struct ib_sa_device *sa_dev = 2304 container_of(handler, typeof(*sa_dev), event_handler); 2305 u8 port_num = event->element.port_num - sa_dev->start_port; 2306 struct ib_sa_port *port = &sa_dev->port[port_num]; 2307 2308 if (!rdma_cap_ib_sa(handler->device, port->port_num)) 2309 return; 2310 2311 spin_lock_irqsave(&port->ah_lock, flags); 2312 if (port->sm_ah) 2313 kref_put(&port->sm_ah->ref, free_sm_ah); 2314 port->sm_ah = NULL; 2315 spin_unlock_irqrestore(&port->ah_lock, flags); 2316 2317 if (event->event == IB_EVENT_SM_CHANGE || 2318 event->event == IB_EVENT_CLIENT_REREGISTER || 2319 event->event == IB_EVENT_LID_CHANGE || 2320 event->event == IB_EVENT_PORT_ACTIVE) { 2321 unsigned long delay = 2322 msecs_to_jiffies(IB_SA_CPI_RETRY_WAIT); 2323 2324 spin_lock_irqsave(&port->classport_lock, flags); 2325 port->classport_info.valid = false; 2326 port->classport_info.retry_cnt = 0; 2327 spin_unlock_irqrestore(&port->classport_lock, flags); 2328 queue_delayed_work(ib_wq, 2329 &port->ib_cpi_work, delay); 2330 } 2331 queue_work(ib_wq, &sa_dev->port[port_num].update_task); 2332 } 2333 } 2334 2335 static void ib_sa_add_one(struct ib_device *device) 2336 { 2337 struct ib_sa_device *sa_dev; 2338 int s, e, i; 2339 int count = 0; 2340 2341 s = rdma_start_port(device); 2342 e = rdma_end_port(device); 2343 2344 sa_dev = kzalloc(sizeof *sa_dev + 2345 (e - s + 1) * sizeof (struct ib_sa_port), 2346 GFP_KERNEL); 2347 if (!sa_dev) 2348 return; 2349 2350 sa_dev->start_port = s; 2351 sa_dev->end_port = e; 2352 2353 for (i = 0; i <= e - s; ++i) { 2354 spin_lock_init(&sa_dev->port[i].ah_lock); 2355 if (!rdma_cap_ib_sa(device, i + 1)) 2356 continue; 2357 2358 sa_dev->port[i].sm_ah = NULL; 2359 sa_dev->port[i].port_num = i + s; 2360 2361 spin_lock_init(&sa_dev->port[i].classport_lock); 2362 sa_dev->port[i].classport_info.valid = false; 2363 2364 sa_dev->port[i].agent = 2365 ib_register_mad_agent(device, i + s, IB_QPT_GSI, 2366 NULL, 0, send_handler, 2367 recv_handler, sa_dev, 0); 2368 if (IS_ERR(sa_dev->port[i].agent)) 2369 goto err; 2370 2371 INIT_WORK(&sa_dev->port[i].update_task, update_sm_ah); 2372 INIT_DELAYED_WORK(&sa_dev->port[i].ib_cpi_work, 2373 update_ib_cpi); 2374 2375 count++; 2376 } 2377 2378 if (!count) 2379 goto free; 2380 2381 ib_set_client_data(device, &sa_client, sa_dev); 2382 2383 /* 2384 * We register our event handler after everything is set up, 2385 * and then update our cached info after the event handler is 2386 * registered to avoid any problems if a port changes state 2387 * during our initialization. 2388 */ 2389 2390 INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event); 2391 ib_register_event_handler(&sa_dev->event_handler); 2392 2393 for (i = 0; i <= e - s; ++i) { 2394 if (rdma_cap_ib_sa(device, i + 1)) 2395 update_sm_ah(&sa_dev->port[i].update_task); 2396 } 2397 2398 return; 2399 2400 err: 2401 while (--i >= 0) { 2402 if (rdma_cap_ib_sa(device, i + 1)) 2403 ib_unregister_mad_agent(sa_dev->port[i].agent); 2404 } 2405 free: 2406 kfree(sa_dev); 2407 return; 2408 } 2409 2410 static void ib_sa_remove_one(struct ib_device *device, void *client_data) 2411 { 2412 struct ib_sa_device *sa_dev = client_data; 2413 int i; 2414 2415 if (!sa_dev) 2416 return; 2417 2418 ib_unregister_event_handler(&sa_dev->event_handler); 2419 flush_workqueue(ib_wq); 2420 2421 for (i = 0; i <= sa_dev->end_port - sa_dev->start_port; ++i) { 2422 if (rdma_cap_ib_sa(device, i + 1)) { 2423 cancel_delayed_work_sync(&sa_dev->port[i].ib_cpi_work); 2424 ib_unregister_mad_agent(sa_dev->port[i].agent); 2425 if (sa_dev->port[i].sm_ah) 2426 kref_put(&sa_dev->port[i].sm_ah->ref, free_sm_ah); 2427 } 2428 2429 } 2430 2431 kfree(sa_dev); 2432 } 2433 2434 int ib_sa_init(void) 2435 { 2436 int ret; 2437 2438 get_random_bytes(&tid, sizeof tid); 2439 2440 atomic_set(&ib_nl_sa_request_seq, 0); 2441 2442 ret = ib_register_client(&sa_client); 2443 if (ret) { 2444 pr_err("Couldn't register ib_sa client\n"); 2445 goto err1; 2446 } 2447 2448 ret = mcast_init(); 2449 if (ret) { 2450 pr_err("Couldn't initialize multicast handling\n"); 2451 goto err2; 2452 } 2453 2454 ib_nl_wq = alloc_ordered_workqueue("ib_nl_sa_wq", WQ_MEM_RECLAIM); 2455 if (!ib_nl_wq) { 2456 ret = -ENOMEM; 2457 goto err3; 2458 } 2459 2460 INIT_DELAYED_WORK(&ib_nl_timed_work, ib_nl_request_timeout); 2461 2462 return 0; 2463 2464 err3: 2465 mcast_cleanup(); 2466 err2: 2467 ib_unregister_client(&sa_client); 2468 err1: 2469 return ret; 2470 } 2471 2472 void ib_sa_cleanup(void) 2473 { 2474 cancel_delayed_work(&ib_nl_timed_work); 2475 flush_workqueue(ib_nl_wq); 2476 destroy_workqueue(ib_nl_wq); 2477 mcast_cleanup(); 2478 ib_unregister_client(&sa_client); 2479 idr_destroy(&query_idr); 2480 } 2481