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