drivers/infiniband/core/sa_query.c

   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 }