kernel/drivers/infiniband/core/sa_query.c

   1 /*
   2  * Copyright (c) 2004 Topspin Communications.  All rights reserved.
   3  * Copyright (c) 2005 Voltaire, Inc.  All rights reserved.
   4  * Copyright (c) 2006 Intel Corporation.  All rights reserved.
   5  *
   6  * This software is available to you under a choice of one of two
   7  * licenses.  You may choose to be licensed under the terms of the GNU
   8  * General Public License (GPL) Version 2, available from the file
   9  * COPYING in the main directory of this source tree, or the
  10  * OpenIB.org BSD license below:
  11  *
  12  *     Redistribution and use in source and binary forms, with or
  13  *     without modification, are permitted provided that the following
  14  *     conditions are met:
  15  *
  16  *      - Redistributions of source code must retain the above
  17  *        copyright notice, this list of conditions and the following
  18  *        disclaimer.
  19  *
  20  *      - Redistributions in binary form must reproduce the above
  21  *        copyright notice, this list of conditions and the following
  22  *        disclaimer in the documentation and/or other materials
  23  *        provided with the distribution.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32  * SOFTWARE.
  33  */
  34
  35 #include <linux/module.h>
  36 #include <linux/init.h>
  37 #include <linux/err.h>
  38 #include <linux/random.h>
  39 #include <linux/spinlock.h>
  40 #include <linux/slab.h>
  41 #include <linux/dma-mapping.h>
  42 #include <linux/kref.h>
  43 #include <linux/idr.h>
  44 #include <linux/workqueue.h>
  45 #include <uapi/linux/if_ether.h>
  46 #include <rdma/ib_pack.h>
  47 #include <rdma/ib_cache.h>
  48 #include <rdma/rdma_netlink.h>
  49 #include <net/netlink.h>
  50 #include <uapi/rdma/ib_user_sa.h>
  51 #include <rdma/ib_marshall.h>
  52 #include "sa.h"
  53
  54 MODULE_AUTHOR("Roland Dreier");
  55 MODULE_DESCRIPTION("InfiniBand subnet administration query support");
  56 MODULE_LICENSE("Dual BSD/GPL");
  57
  58 #define IB_SA_LOCAL_SVC_TIMEOUT_MIN             100
  59 #define IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT         2000
  60 #define IB_SA_LOCAL_SVC_TIMEOUT_MAX             200000
  61 static int sa_local_svc_timeout_ms = IB_SA_LOCAL_SVC_TIMEOUT_DEFAULT;
  62
  63 struct ib_sa_sm_ah {
  64         struct ib_ah        *ah;
  65         struct kref          ref;
  66         u16                  pkey_index;
  67         u8                   src_path_mask;
  68 };
  69
  70 struct ib_sa_port {
  71         struct ib_mad_agent *agent;
  72         struct ib_sa_sm_ah  *sm_ah;
  73         struct work_struct   update_task;
  74         spinlock_t           ah_lock;
  75         u8                   port_num;
  76 };
  77
  78 struct ib_sa_device {
  79         int                     start_port, end_port;
  80         struct ib_event_handler event_handler;
  81         struct ib_sa_port port[0];
  82 };
  83
  84 struct ib_sa_query {
  85         void (*callback)(struct ib_sa_query *, int, struct ib_sa_mad *);
  86         void (*release)(struct ib_sa_query *);
  87         struct ib_sa_client    *client;
  88         struct ib_sa_port      *port;
  89         struct ib_mad_send_buf *mad_buf;
  90         struct ib_sa_sm_ah     *sm_ah;
  91         int                     id;
  92         u32                     flags;
  93         struct list_head        list; /* Local svc request list */
  94         u32                     seq; /* Local svc request sequence number */
  95         unsigned long           timeout; /* Local svc timeout */
  96         u8                      path_use; /* How will the pathrecord be used */
  97 };
  98
  99 #define IB_SA_ENABLE_LOCAL_SERVICE      0x00000001
 100 #define IB_SA_CANCEL                    0x00000002
 101
 102 struct ib_sa_service_query {
 103         void (*callback)(int, struct ib_sa_service_rec *, void *);
 104         void *context;
 105         struct ib_sa_query sa_query;
 106 };
 107
 108 struct ib_sa_path_query {
 109         void (*callback)(int, struct ib_sa_path_rec *, void *);
 110         void *context;
 111         struct ib_sa_query sa_query;
 112 };
 113
 114 struct ib_sa_guidinfo_query {
 115         void (*callback)(int, struct ib_sa_guidinfo_rec *, void *);
 116         void *context;
 117         struct ib_sa_query sa_query;
 118 };
 119
 120 struct ib_sa_mcmember_query {
 121         void (*callback)(int, struct ib_sa_mcmember_rec *, void *);
 122         void *context;
 123         struct ib_sa_query sa_query;
 124 };
 125
 126 static LIST_HEAD(ib_nl_request_list);
 127 static DEFINE_SPINLOCK(ib_nl_request_lock);
 128 static atomic_t ib_nl_sa_request_seq;
 129 static struct workqueue_struct *ib_nl_wq;
 130 static struct delayed_work ib_nl_timed_work;
 131 static const struct nla_policy ib_nl_policy[LS_NLA_TYPE_MAX] = {
 132         [LS_NLA_TYPE_PATH_RECORD]       = {.type = NLA_BINARY,
 133                 .len = sizeof(struct ib_path_rec_data)},
 134         [LS_NLA_TYPE_TIMEOUT]           = {.type = NLA_U32},
 135         [LS_NLA_TYPE_SERVICE_ID]        = {.type = NLA_U64},
 136         [LS_NLA_TYPE_DGID]              = {.type = NLA_BINARY,
 137                 .len = sizeof(struct rdma_nla_ls_gid)},
 138         [LS_NLA_TYPE_SGID]              = {.type = NLA_BINARY,
 139                 .len = sizeof(struct rdma_nla_ls_gid)},
 140         [LS_NLA_TYPE_TCLASS]            = {.type = NLA_U8},
 141         [LS_NLA_TYPE_PKEY]              = {.type = NLA_U16},
 142         [LS_NLA_TYPE_QOS_CLASS]         = {.type = NLA_U16},
 143 };
 144
 145
 146 static void ib_sa_add_one(struct ib_device *device);
 147 static void ib_sa_remove_one(struct ib_device *device, void *client_data);
 148
 149 static struct ib_client sa_client = {
 150         .name   = "sa",
 151         .add    = ib_sa_add_one,
 152         .remove = ib_sa_remove_one
 153 };
 154
 155 static DEFINE_SPINLOCK(idr_lock);
 156 static DEFINE_IDR(query_idr);
 157
 158 static DEFINE_SPINLOCK(tid_lock);
 159 static u32 tid;
 160
 161 #define PATH_REC_FIELD(field) \
 162         .struct_offset_bytes = offsetof(struct ib_sa_path_rec, field),          \
 163         .struct_size_bytes   = sizeof ((struct ib_sa_path_rec *) 0)->field,     \
 164         .field_name          = "sa_path_rec:" #field
 165
 166 static const struct ib_field path_rec_table[] = {
 167         { PATH_REC_FIELD(service_id),
 168           .offset_words = 0,
 169           .offset_bits  = 0,
 170           .size_bits    = 64 },
 171         { PATH_REC_FIELD(dgid),
 172           .offset_words = 2,
 173           .offset_bits  = 0,
 174           .size_bits    = 128 },
 175         { PATH_REC_FIELD(sgid),
 176           .offset_words = 6,
 177           .offset_bits  = 0,
 178           .size_bits    = 128 },
 179         { PATH_REC_FIELD(dlid),
 180           .offset_words = 10,
 181           .offset_bits  = 0,
 182           .size_bits    = 16 },
 183         { PATH_REC_FIELD(slid),
 184           .offset_words = 10,
 185           .offset_bits  = 16,
 186           .size_bits    = 16 },
 187         { PATH_REC_FIELD(raw_traffic),
 188           .offset_words = 11,
 189           .offset_bits  = 0,
 190           .size_bits    = 1 },
 191         { RESERVED,
 192           .offset_words = 11,
 193           .offset_bits  = 1,
 194           .size_bits    = 3 },
 195         { PATH_REC_FIELD(flow_label),
 196           .offset_words = 11,
 197           .offset_bits  = 4,
 198           .size_bits    = 20 },
 199         { PATH_REC_FIELD(hop_limit),
 200           .offset_words = 11,
 201           .offset_bits  = 24,
 202           .size_bits    = 8 },
 203         { PATH_REC_FIELD(traffic_class),
 204           .offset_words = 12,
 205           .offset_bits  = 0,
 206           .size_bits    = 8 },
 207         { PATH_REC_FIELD(reversible),
 208           .offset_words = 12,
 209           .offset_bits  = 8,
 210           .size_bits    = 1 },
 211         { PATH_REC_FIELD(numb_path),
 212           .offset_words = 12,
 213           .offset_bits  = 9,
 214           .size_bits    = 7 },
 215         { PATH_REC_FIELD(pkey),
 216           .offset_words = 12,
 217           .offset_bits  = 16,
 218           .size_bits    = 16 },
 219         { PATH_REC_FIELD(qos_class),
 220           .offset_words = 13,
 221           .offset_bits  = 0,
 222           .size_bits    = 12 },
 223         { PATH_REC_FIELD(sl),
 224           .offset_words = 13,
 225           .offset_bits  = 12,
 226           .size_bits    = 4 },
 227         { PATH_REC_FIELD(mtu_selector),
 228           .offset_words = 13,
 229           .offset_bits  = 16,
 230           .size_bits    = 2 },
 231         { PATH_REC_FIELD(mtu),
 232           .offset_words = 13,
 233           .offset_bits  = 18,
 234           .size_bits    = 6 },
 235         { PATH_REC_FIELD(rate_selector),
 236           .offset_words = 13,
 237           .offset_bits  = 24,
 238           .size_bits    = 2 },
 239         { PATH_REC_FIELD(rate),
 240           .offset_words = 13,
 241           .offset_bits  = 26,
 242           .size_bits    = 6 },
 243         { PATH_REC_FIELD(packet_life_time_selector),
 244           .offset_words = 14,
 245           .offset_bits  = 0,
 246           .size_bits    = 2 },
 247         { PATH_REC_FIELD(packet_life_time),
 248           .offset_words = 14,
 249           .offset_bits  = 2,
 250           .size_bits    = 6 },
 251         { PATH_REC_FIELD(preference),
 252           .offset_words = 14,
 253           .offset_bits  = 8,
 254           .size_bits    = 8 },
 255         { RESERVED,
 256           .offset_words = 14,
 257           .offset_bits  = 16,
 258           .size_bits    = 48 },
 259 };
 260
 261 #define MCMEMBER_REC_FIELD(field) \
 262         .struct_offset_bytes = offsetof(struct ib_sa_mcmember_rec, field),      \
 263         .struct_size_bytes   = sizeof ((struct ib_sa_mcmember_rec *) 0)->field, \
 264         .field_name          = "sa_mcmember_rec:" #field
 265
 266 static const struct ib_field mcmember_rec_table[] = {
 267         { MCMEMBER_REC_FIELD(mgid),
 268           .offset_words = 0,
 269           .offset_bits  = 0,
 270           .size_bits    = 128 },
 271         { MCMEMBER_REC_FIELD(port_gid),
 272           .offset_words = 4,
 273           .offset_bits  = 0,
 274           .size_bits    = 128 },
 275         { MCMEMBER_REC_FIELD(qkey),
 276           .offset_words = 8,
 277           .offset_bits  = 0,
 278           .size_bits    = 32 },
 279         { MCMEMBER_REC_FIELD(mlid),
 280           .offset_words = 9,
 281           .offset_bits  = 0,
 282           .size_bits    = 16 },
 283         { MCMEMBER_REC_FIELD(mtu_selector),
 284           .offset_words = 9,
 285           .offset_bits  = 16,
 286           .size_bits    = 2 },
 287         { MCMEMBER_REC_FIELD(mtu),
 288           .offset_words = 9,
 289           .offset_bits  = 18,
 290           .size_bits    = 6 },
 291         { MCMEMBER_REC_FIELD(traffic_class),
 292           .offset_words = 9,
 293           .offset_bits  = 24,
 294           .size_bits    = 8 },
 295         { MCMEMBER_REC_FIELD(pkey),
 296           .offset_words = 10,
 297           .offset_bits  = 0,
 298           .size_bits    = 16 },
 299         { MCMEMBER_REC_FIELD(rate_selector),
 300           .offset_words = 10,
 301           .offset_bits  = 16,
 302           .size_bits    = 2 },
 303         { MCMEMBER_REC_FIELD(rate),
 304           .offset_words = 10,
 305           .offset_bits  = 18,
 306           .size_bits    = 6 },
 307         { MCMEMBER_REC_FIELD(packet_life_time_selector),
 308           .offset_words = 10,
 309           .offset_bits  = 24,
 310           .size_bits    = 2 },
 311         { MCMEMBER_REC_FIELD(packet_life_time),
 312           .offset_words = 10,
 313           .offset_bits  = 26,
 314           .size_bits    = 6 },
 315         { MCMEMBER_REC_FIELD(sl),
 316           .offset_words = 11,
 317           .offset_bits  = 0,
 318           .size_bits    = 4 },
 319         { MCMEMBER_REC_FIELD(flow_label),
 320           .offset_words = 11,
 321           .offset_bits  = 4,
 322           .size_bits    = 20 },
 323         { MCMEMBER_REC_FIELD(hop_limit),
 324           .offset_words = 11,
 325           .offset_bits  = 24,
 326           .size_bits    = 8 },
 327         { MCMEMBER_REC_FIELD(scope),
 328           .offset_words = 12,
 329           .offset_bits  = 0,
 330           .size_bits    = 4 },
 331         { MCMEMBER_REC_FIELD(join_state),
 332           .offset_words = 12,
 333           .offset_bits  = 4,
 334           .size_bits    = 4 },
 335         { MCMEMBER_REC_FIELD(proxy_join),
 336           .offset_words = 12,
 337           .offset_bits  = 8,
 338           .size_bits    = 1 },
 339         { RESERVED,
 340           .offset_words = 12,
 341           .offset_bits  = 9,
 342           .size_bits    = 23 },
 343 };
 344
 345 #define SERVICE_REC_FIELD(field) \
 346         .struct_offset_bytes = offsetof(struct ib_sa_service_rec, field),       \
 347         .struct_size_bytes   = sizeof ((struct ib_sa_service_rec *) 0)->field,  \
 348         .field_name          = "sa_service_rec:" #field
 349
 350 static const struct ib_field service_rec_table[] = {
 351         { SERVICE_REC_FIELD(id),
 352           .offset_words = 0,
 353           .offset_bits  = 0,
 354           .size_bits    = 64 },
 355         { SERVICE_REC_FIELD(gid),
 356           .offset_words = 2,
 357           .offset_bits  = 0,
 358           .size_bits    = 128 },
 359         { SERVICE_REC_FIELD(pkey),
 360           .offset_words = 6,
 361           .offset_bits  = 0,
 362           .size_bits    = 16 },
 363         { SERVICE_REC_FIELD(lease),
 364           .offset_words = 7,
 365           .offset_bits  = 0,
 366           .size_bits    = 32 },
 367         { SERVICE_REC_FIELD(key),
 368           .offset_words = 8,
 369           .offset_bits  = 0,
 370           .size_bits    = 128 },
 371         { SERVICE_REC_FIELD(name),
 372           .offset_words = 12,
 373           .offset_bits  = 0,
 374           .size_bits    = 64*8 },
 375         { SERVICE_REC_FIELD(data8),
 376           .offset_words = 28,
 377           .offset_bits  = 0,
 378           .size_bits    = 16*8 },
 379         { SERVICE_REC_FIELD(data16),
 380           .offset_words = 32,
 381           .offset_bits  = 0,
 382           .size_bits    = 8*16 },
 383         { SERVICE_REC_FIELD(data32),
 384           .offset_words = 36,
 385           .offset_bits  = 0,
 386           .size_bits    = 4*32 },
 387         { SERVICE_REC_FIELD(data64),
 388           .offset_words = 40,
 389           .offset_bits  = 0,
 390           .size_bits    = 2*64 },
 391 };
 392
 393 #define GUIDINFO_REC_FIELD(field) \
 394         .struct_offset_bytes = offsetof(struct ib_sa_guidinfo_rec, field),      \
 395         .struct_size_bytes   = sizeof((struct ib_sa_guidinfo_rec *) 0)->field,  \
 396         .field_name          = "sa_guidinfo_rec:" #field
 397
 398 static const struct ib_field guidinfo_rec_table[] = {
 399         { GUIDINFO_REC_FIELD(lid),
 400           .offset_words = 0,
 401           .offset_bits  = 0,
 402           .size_bits    = 16 },
 403         { GUIDINFO_REC_FIELD(block_num),
 404           .offset_words = 0,
 405           .offset_bits  = 16,
 406           .size_bits    = 8 },
 407         { GUIDINFO_REC_FIELD(res1),
 408           .offset_words = 0,
 409           .offset_bits  = 24,
 410           .size_bits    = 8 },
 411         { GUIDINFO_REC_FIELD(res2),
 412           .offset_words = 1,
 413           .offset_bits  = 0,
 414           .size_bits    = 32 },
 415         { GUIDINFO_REC_FIELD(guid_info_list),
 416           .offset_words = 2,
 417           .offset_bits  = 0,
 418           .size_bits    = 512 },
 419 };
 420
 421 static inline void ib_sa_disable_local_svc(struct ib_sa_query *query)
 422 {
 423         query->flags &= ~IB_SA_ENABLE_LOCAL_SERVICE;
 424 }
 425
 426 static inline int ib_sa_query_cancelled(struct ib_sa_query *query)
 427 {
 428         return (query->flags & IB_SA_CANCEL);
 429 }
 430
 431 static void ib_nl_set_path_rec_attrs(struct sk_buff *skb,
 432                                      struct ib_sa_query *query)
 433 {
 434         struct ib_sa_path_rec *sa_rec = query->mad_buf->context[1];
 435         struct ib_sa_mad *mad = query->mad_buf->mad;
 436         ib_sa_comp_mask comp_mask = mad->sa_hdr.comp_mask;
 437         u16 val16;
 438         u64 val64;
 439         struct rdma_ls_resolve_header *header;
 440
 441         query->mad_buf->context[1] = NULL;
 442
 443         /* Construct the family header first */
 444         header = (struct rdma_ls_resolve_header *)
 445                 skb_put(skb, NLMSG_ALIGN(sizeof(*header)));
 446         memcpy(header->device_name, query->port->agent->device->name,
 447                LS_DEVICE_NAME_MAX);
 448         header->port_num = query->port->port_num;
 449
 450         if ((comp_mask & IB_SA_PATH_REC_REVERSIBLE) &&
 451             sa_rec->reversible != 0)
 452                 query->path_use = LS_RESOLVE_PATH_USE_GMP;
 453         else
 454                 query->path_use = LS_RESOLVE_PATH_USE_UNIDIRECTIONAL;
 455         header->path_use = query->path_use;
 456
 457         /* Now build the attributes */
 458         if (comp_mask & IB_SA_PATH_REC_SERVICE_ID) {
 459                 val64 = be64_to_cpu(sa_rec->service_id);
 460                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_SERVICE_ID,
 461                         sizeof(val64), &val64);
 462         }
 463         if (comp_mask & IB_SA_PATH_REC_DGID)
 464                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_DGID,
 465                         sizeof(sa_rec->dgid), &sa_rec->dgid);
 466         if (comp_mask & IB_SA_PATH_REC_SGID)
 467                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_SGID,
 468                         sizeof(sa_rec->sgid), &sa_rec->sgid);
 469         if (comp_mask & IB_SA_PATH_REC_TRAFFIC_CLASS)
 470                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_TCLASS,
 471                         sizeof(sa_rec->traffic_class), &sa_rec->traffic_class);
 472
 473         if (comp_mask & IB_SA_PATH_REC_PKEY) {
 474                 val16 = be16_to_cpu(sa_rec->pkey);
 475                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_PKEY,
 476                         sizeof(val16), &val16);
 477         }
 478         if (comp_mask & IB_SA_PATH_REC_QOS_CLASS) {
 479                 val16 = be16_to_cpu(sa_rec->qos_class);
 480                 nla_put(skb, RDMA_NLA_F_MANDATORY | LS_NLA_TYPE_QOS_CLASS,
 481                         sizeof(val16), &val16);
 482         }
 483 }
 484
 485 static int ib_nl_get_path_rec_attrs_len(ib_sa_comp_mask comp_mask)
 486 {
 487         int len = 0;
 488
 489         if (comp_mask & IB_SA_PATH_REC_SERVICE_ID)
 490                 len += nla_total_size(sizeof(u64));
 491         if (comp_mask & IB_SA_PATH_REC_DGID)
 492                 len += nla_total_size(sizeof(struct rdma_nla_ls_gid));
 493         if (comp_mask & IB_SA_PATH_REC_SGID)
 494                 len += nla_total_size(sizeof(struct rdma_nla_ls_gid));
 495         if (comp_mask & IB_SA_PATH_REC_TRAFFIC_CLASS)
 496                 len += nla_total_size(sizeof(u8));
 497         if (comp_mask & IB_SA_PATH_REC_PKEY)
 498                 len += nla_total_size(sizeof(u16));
 499         if (comp_mask & IB_SA_PATH_REC_QOS_CLASS)
 500                 len += nla_total_size(sizeof(u16));
 501
 502         /*
 503          * Make sure that at least some of the required comp_mask bits are
 504          * set.
 505          */
 506         if (WARN_ON(len == 0))
 507                 return len;
 508
 509         /* Add the family header */
 510         len += NLMSG_ALIGN(sizeof(struct rdma_ls_resolve_header));
 511
 512         return len;
 513 }
 514
 515 static int ib_nl_send_msg(struct ib_sa_query *query, gfp_t gfp_mask)
 516 {
 517         struct sk_buff *skb = NULL;
 518         struct nlmsghdr *nlh;
 519         void *data;
 520         int ret = 0;
 521         struct ib_sa_mad *mad;
 522         int len;
 523
 524         mad = query->mad_buf->mad;
 525         len = ib_nl_get_path_rec_attrs_len(mad->sa_hdr.comp_mask);
 526         if (len <= 0)
 527                 return -EMSGSIZE;
 528
 529         skb = nlmsg_new(len, gfp_mask);
 530         if (!skb)
 531                 return -ENOMEM;
 532
 533         /* Put nlmsg header only for now */
 534         data = ibnl_put_msg(skb, &nlh, query->seq, 0, RDMA_NL_LS,
 535                             RDMA_NL_LS_OP_RESOLVE, NLM_F_REQUEST);
 536         if (!data) {
 537                 kfree_skb(skb);
 538                 return -EMSGSIZE;
 539         }
 540
 541         /* Add attributes */
 542         ib_nl_set_path_rec_attrs(skb, query);
 543
 544         /* Repair the nlmsg header length */
 545         nlmsg_end(skb, nlh);
 546
 547         ret = ibnl_multicast(skb, nlh, RDMA_NL_GROUP_LS, gfp_mask);
 548         if (!ret)
 549                 ret = len;
 550         else
 551                 ret = 0;
 552
 553         return ret;
 554 }
 555
 556 static int ib_nl_make_request(struct ib_sa_query *query, gfp_t gfp_mask)
 557 {
 558         unsigned long flags;
 559         unsigned long delay;
 560         int ret;
 561
 562         INIT_LIST_HEAD(&query->list);
 563         query->seq = (u32)atomic_inc_return(&ib_nl_sa_request_seq);
 564
 565         /* Put the request on the list first.*/
 566         spin_lock_irqsave(&ib_nl_request_lock, flags);
 567         delay = msecs_to_jiffies(sa_local_svc_timeout_ms);
 568         query->timeout = delay + jiffies;
 569         list_add_tail(&query->list, &ib_nl_request_list);
 570         /* Start the timeout if this is the only request */
 571         if (ib_nl_request_list.next == &query->list)
 572                 queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay);
 573         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 574
 575         ret = ib_nl_send_msg(query, gfp_mask);
 576         if (ret <= 0) {
 577                 ret = -EIO;
 578                 /* Remove the request */
 579                 spin_lock_irqsave(&ib_nl_request_lock, flags);
 580                 list_del(&query->list);
 581                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 582         } else {
 583                 ret = 0;
 584         }
 585
 586         return ret;
 587 }
 588
 589 static int ib_nl_cancel_request(struct ib_sa_query *query)
 590 {
 591         unsigned long flags;
 592         struct ib_sa_query *wait_query;
 593         int found = 0;
 594
 595         spin_lock_irqsave(&ib_nl_request_lock, flags);
 596         list_for_each_entry(wait_query, &ib_nl_request_list, list) {
 597                 /* Let the timeout to take care of the callback */
 598                 if (query == wait_query) {
 599                         query->flags |= IB_SA_CANCEL;
 600                         query->timeout = jiffies;
 601                         list_move(&query->list, &ib_nl_request_list);
 602                         found = 1;
 603                         mod_delayed_work(ib_nl_wq, &ib_nl_timed_work, 1);
 604                         break;
 605                 }
 606         }
 607         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 608
 609         return found;
 610 }
 611
 612 static void send_handler(struct ib_mad_agent *agent,
 613                          struct ib_mad_send_wc *mad_send_wc);
 614
 615 static void ib_nl_process_good_resolve_rsp(struct ib_sa_query *query,
 616                                            const struct nlmsghdr *nlh)
 617 {
 618         struct ib_mad_send_wc mad_send_wc;
 619         struct ib_sa_mad *mad = NULL;
 620         const struct nlattr *head, *curr;
 621         struct ib_path_rec_data  *rec;
 622         int len, rem;
 623         u32 mask = 0;
 624         int status = -EIO;
 625
 626         if (query->callback) {
 627                 head = (const struct nlattr *) nlmsg_data(nlh);
 628                 len = nlmsg_len(nlh);
 629                 switch (query->path_use) {
 630                 case LS_RESOLVE_PATH_USE_UNIDIRECTIONAL:
 631                         mask = IB_PATH_PRIMARY | IB_PATH_OUTBOUND;
 632                         break;
 633
 634                 case LS_RESOLVE_PATH_USE_ALL:
 635                 case LS_RESOLVE_PATH_USE_GMP:
 636                 default:
 637                         mask = IB_PATH_PRIMARY | IB_PATH_GMP |
 638                                 IB_PATH_BIDIRECTIONAL;
 639                         break;
 640                 }
 641                 nla_for_each_attr(curr, head, len, rem) {
 642                         if (curr->nla_type == LS_NLA_TYPE_PATH_RECORD) {
 643                                 rec = nla_data(curr);
 644                                 /*
 645                                  * Get the first one. In the future, we may
 646                                  * need to get up to 6 pathrecords.
 647                                  */
 648                                 if ((rec->flags & mask) == mask) {
 649                                         mad = query->mad_buf->mad;
 650                                         mad->mad_hdr.method |=
 651                                                 IB_MGMT_METHOD_RESP;
 652                                         memcpy(mad->data, rec->path_rec,
 653                                                sizeof(rec->path_rec));
 654                                         status = 0;
 655                                         break;
 656                                 }
 657                         }
 658                 }
 659                 query->callback(query, status, mad);
 660         }
 661
 662         mad_send_wc.send_buf = query->mad_buf;
 663         mad_send_wc.status = IB_WC_SUCCESS;
 664         send_handler(query->mad_buf->mad_agent, &mad_send_wc);
 665 }
 666
 667 static void ib_nl_request_timeout(struct work_struct *work)
 668 {
 669         unsigned long flags;
 670         struct ib_sa_query *query;
 671         unsigned long delay;
 672         struct ib_mad_send_wc mad_send_wc;
 673         int ret;
 674
 675         spin_lock_irqsave(&ib_nl_request_lock, flags);
 676         while (!list_empty(&ib_nl_request_list)) {
 677                 query = list_entry(ib_nl_request_list.next,
 678                                    struct ib_sa_query, list);
 679
 680                 if (time_after(query->timeout, jiffies)) {
 681                         delay = query->timeout - jiffies;
 682                         if ((long)delay <= 0)
 683                                 delay = 1;
 684                         queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay);
 685                         break;
 686                 }
 687
 688                 list_del(&query->list);
 689                 ib_sa_disable_local_svc(query);
 690                 /* Hold the lock to protect against query cancellation */
 691                 if (ib_sa_query_cancelled(query))
 692                         ret = -1;
 693                 else
 694                         ret = ib_post_send_mad(query->mad_buf, NULL);
 695                 if (ret) {
 696                         mad_send_wc.send_buf = query->mad_buf;
 697                         mad_send_wc.status = IB_WC_WR_FLUSH_ERR;
 698                         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 699                         send_handler(query->port->agent, &mad_send_wc);
 700                         spin_lock_irqsave(&ib_nl_request_lock, flags);
 701                 }
 702         }
 703         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 704 }
 705
 706 static int ib_nl_handle_set_timeout(struct sk_buff *skb,
 707                                     struct netlink_callback *cb)
 708 {
 709         const struct nlmsghdr *nlh = (struct nlmsghdr *)cb->nlh;
 710         int timeout, delta, abs_delta;
 711         const struct nlattr *attr;
 712         unsigned long flags;
 713         struct ib_sa_query *query;
 714         long delay = 0;
 715         struct nlattr *tb[LS_NLA_TYPE_MAX];
 716         int ret;
 717
 718         if (!netlink_capable(skb, CAP_NET_ADMIN))
 719                 return -EPERM;
 720
 721         ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh),
 722                         nlmsg_len(nlh), ib_nl_policy);
 723         attr = (const struct nlattr *)tb[LS_NLA_TYPE_TIMEOUT];
 724         if (ret || !attr)
 725                 goto settimeout_out;
 726
 727         timeout = *(int *) nla_data(attr);
 728         if (timeout < IB_SA_LOCAL_SVC_TIMEOUT_MIN)
 729                 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MIN;
 730         if (timeout > IB_SA_LOCAL_SVC_TIMEOUT_MAX)
 731                 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MAX;
 732
 733         delta = timeout - sa_local_svc_timeout_ms;
 734         if (delta < 0)
 735                 abs_delta = -delta;
 736         else
 737                 abs_delta = delta;
 738
 739         if (delta != 0) {
 740                 spin_lock_irqsave(&ib_nl_request_lock, flags);
 741                 sa_local_svc_timeout_ms = timeout;
 742                 list_for_each_entry(query, &ib_nl_request_list, list) {
 743                         if (delta < 0 && abs_delta > query->timeout)
 744                                 query->timeout = 0;
 745                         else
 746                                 query->timeout += delta;
 747
 748                         /* Get the new delay from the first entry */
 749                         if (!delay) {
 750                                 delay = query->timeout - jiffies;
 751                                 if (delay <= 0)
 752                                         delay = 1;
 753                         }
 754                 }
 755                 if (delay)
 756                         mod_delayed_work(ib_nl_wq, &ib_nl_timed_work,
 757                                          (unsigned long)delay);
 758                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 759         }
 760
 761 settimeout_out:
 762         return skb->len;
 763 }
 764
 765 static inline int ib_nl_is_good_resolve_resp(const struct nlmsghdr *nlh)
 766 {
 767         struct nlattr *tb[LS_NLA_TYPE_MAX];
 768         int ret;
 769
 770         if (nlh->nlmsg_flags & RDMA_NL_LS_F_ERR)
 771                 return 0;
 772
 773         ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh),
 774                         nlmsg_len(nlh), ib_nl_policy);
 775         if (ret)
 776                 return 0;
 777
 778         return 1;
 779 }
 780
 781 static int ib_nl_handle_resolve_resp(struct sk_buff *skb,
 782                                      struct netlink_callback *cb)
 783 {
 784         const struct nlmsghdr *nlh = (struct nlmsghdr *)cb->nlh;
 785         unsigned long flags;
 786         struct ib_sa_query *query;
 787         struct ib_mad_send_buf *send_buf;
 788         struct ib_mad_send_wc mad_send_wc;
 789         int found = 0;
 790         int ret;
 791
 792         if (!netlink_capable(skb, CAP_NET_ADMIN))
 793                 return -EPERM;
 794
 795         spin_lock_irqsave(&ib_nl_request_lock, flags);
 796         list_for_each_entry(query, &ib_nl_request_list, list) {
 797                 /*
 798                  * If the query is cancelled, let the timeout routine
 799                  * take care of it.
 800                  */
 801                 if (nlh->nlmsg_seq == query->seq) {
 802                         found = !ib_sa_query_cancelled(query);
 803                         if (found)
 804                                 list_del(&query->list);
 805                         break;
 806                 }
 807         }
 808
 809         if (!found) {
 810                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 811                 goto resp_out;
 812         }
 813
 814         send_buf = query->mad_buf;
 815
 816         if (!ib_nl_is_good_resolve_resp(nlh)) {
 817                 /* if the result is a failure, send out the packet via IB */
 818                 ib_sa_disable_local_svc(query);
 819                 ret = ib_post_send_mad(query->mad_buf, NULL);
 820                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 821                 if (ret) {
 822                         mad_send_wc.send_buf = send_buf;
 823                         mad_send_wc.status = IB_WC_GENERAL_ERR;
 824                         send_handler(query->port->agent, &mad_send_wc);
 825                 }
 826         } else {
 827                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 828                 ib_nl_process_good_resolve_rsp(query, nlh);
 829         }
 830
 831 resp_out:
 832         return skb->len;
 833 }
 834
 835 static struct ibnl_client_cbs ib_sa_cb_table[] = {
 836         [RDMA_NL_LS_OP_RESOLVE] = {
 837                 .dump = ib_nl_handle_resolve_resp,
 838                 .module = THIS_MODULE },
 839         [RDMA_NL_LS_OP_SET_TIMEOUT] = {
 840                 .dump = ib_nl_handle_set_timeout,
 841                 .module = THIS_MODULE },
 842 };
 843
 844 static void free_sm_ah(struct kref *kref)
 845 {
 846         struct ib_sa_sm_ah *sm_ah = container_of(kref, struct ib_sa_sm_ah, ref);
 847
 848         ib_destroy_ah(sm_ah->ah);
 849         kfree(sm_ah);
 850 }
 851
 852 static void update_sm_ah(struct work_struct *work)
 853 {
 854         struct ib_sa_port *port =
 855                 container_of(work, struct ib_sa_port, update_task);
 856         struct ib_sa_sm_ah *new_ah;
 857         struct ib_port_attr port_attr;
 858         struct ib_ah_attr   ah_attr;
 859
 860         if (ib_query_port(port->agent->device, port->port_num, &port_attr)) {
 861                 printk(KERN_WARNING "Couldn't query port\n");
 862                 return;
 863         }
 864
 865         new_ah = kmalloc(sizeof *new_ah, GFP_KERNEL);
 866         if (!new_ah) {
 867                 printk(KERN_WARNING "Couldn't allocate new SM AH\n");
 868                 return;
 869         }
 870
 871         kref_init(&new_ah->ref);
 872         new_ah->src_path_mask = (1 << port_attr.lmc) - 1;
 873
 874         new_ah->pkey_index = 0;
 875         if (ib_find_pkey(port->agent->device, port->port_num,
 876                          IB_DEFAULT_PKEY_FULL, &new_ah->pkey_index))
 877                 printk(KERN_ERR "Couldn't find index for default PKey\n");
 878
 879         memset(&ah_attr, 0, sizeof ah_attr);
 880         ah_attr.dlid     = port_attr.sm_lid;
 881         ah_attr.sl       = port_attr.sm_sl;
 882         ah_attr.port_num = port->port_num;
 883
 884         new_ah->ah = ib_create_ah(port->agent->qp->pd, &ah_attr);
 885         if (IS_ERR(new_ah->ah)) {
 886                 printk(KERN_WARNING "Couldn't create new SM AH\n");
 887                 kfree(new_ah);
 888                 return;
 889         }
 890
 891         spin_lock_irq(&port->ah_lock);
 892         if (port->sm_ah)
 893                 kref_put(&port->sm_ah->ref, free_sm_ah);
 894         port->sm_ah = new_ah;
 895         spin_unlock_irq(&port->ah_lock);
 896
 897 }
 898
 899 static void ib_sa_event(struct ib_event_handler *handler, struct ib_event *event)
 900 {
 901         if (event->event == IB_EVENT_PORT_ERR    ||
 902             event->event == IB_EVENT_PORT_ACTIVE ||
 903             event->event == IB_EVENT_LID_CHANGE  ||
 904             event->event == IB_EVENT_PKEY_CHANGE ||
 905             event->event == IB_EVENT_SM_CHANGE   ||
 906             event->event == IB_EVENT_CLIENT_REREGISTER) {
 907                 unsigned long flags;
 908                 struct ib_sa_device *sa_dev =
 909                         container_of(handler, typeof(*sa_dev), event_handler);
 910                 struct ib_sa_port *port =
 911                         &sa_dev->port[event->element.port_num - sa_dev->start_port];
 912
 913                 if (!rdma_cap_ib_sa(handler->device, port->port_num))
 914                         return;
 915
 916                 spin_lock_irqsave(&port->ah_lock, flags);
 917                 if (port->sm_ah)
 918                         kref_put(&port->sm_ah->ref, free_sm_ah);
 919                 port->sm_ah = NULL;
 920                 spin_unlock_irqrestore(&port->ah_lock, flags);
 921
 922                 queue_work(ib_wq, &sa_dev->port[event->element.port_num -
 923                                             sa_dev->start_port].update_task);
 924         }
 925 }
 926
 927 void ib_sa_register_client(struct ib_sa_client *client)
 928 {
 929         atomic_set(&client->users, 1);
 930         init_completion(&client->comp);
 931 }
 932 EXPORT_SYMBOL(ib_sa_register_client);
 933
 934 void ib_sa_unregister_client(struct ib_sa_client *client)
 935 {
 936         ib_sa_client_put(client);
 937         wait_for_completion(&client->comp);
 938 }
 939 EXPORT_SYMBOL(ib_sa_unregister_client);
 940
 941 /**
 942  * ib_sa_cancel_query - try to cancel an SA query
 943  * @id:ID of query to cancel
 944  * @query:query pointer to cancel
 945  *
 946  * Try to cancel an SA query.  If the id and query don't match up or
 947  * the query has already completed, nothing is done.  Otherwise the
 948  * query is canceled and will complete with a status of -EINTR.
 949  */
 950 void ib_sa_cancel_query(int id, struct ib_sa_query *query)
 951 {
 952         unsigned long flags;
 953         struct ib_mad_agent *agent;
 954         struct ib_mad_send_buf *mad_buf;
 955
 956         spin_lock_irqsave(&idr_lock, flags);
 957         if (idr_find(&query_idr, id) != query) {
 958                 spin_unlock_irqrestore(&idr_lock, flags);
 959                 return;
 960         }
 961         agent = query->port->agent;
 962         mad_buf = query->mad_buf;
 963         spin_unlock_irqrestore(&idr_lock, flags);
 964
 965         /*
 966          * If the query is still on the netlink request list, schedule
 967          * it to be cancelled by the timeout routine. Otherwise, it has been
 968          * sent to the MAD layer and has to be cancelled from there.
 969          */
 970         if (!ib_nl_cancel_request(query))
 971                 ib_cancel_mad(agent, mad_buf);
 972 }
 973 EXPORT_SYMBOL(ib_sa_cancel_query);
 974
 975 static u8 get_src_path_mask(struct ib_device *device, u8 port_num)
 976 {
 977         struct ib_sa_device *sa_dev;
 978         struct ib_sa_port   *port;
 979         unsigned long flags;
 980         u8 src_path_mask;
 981
 982         sa_dev = ib_get_client_data(device, &sa_client);
 983         if (!sa_dev)
 984                 return 0x7f;
 985
 986         port  = &sa_dev->port[port_num - sa_dev->start_port];
 987         spin_lock_irqsave(&port->ah_lock, flags);
 988         src_path_mask = port->sm_ah ? port->sm_ah->src_path_mask : 0x7f;
 989         spin_unlock_irqrestore(&port->ah_lock, flags);
 990
 991         return src_path_mask;
 992 }
 993
 994 int ib_init_ah_from_path(struct ib_device *device, u8 port_num,
 995                          struct ib_sa_path_rec *rec, struct ib_ah_attr *ah_attr)
 996 {
 997         int ret;
 998         u16 gid_index;
 999         int force_grh;
1000
1001         memset(ah_attr, 0, sizeof *ah_attr);
1002         ah_attr->dlid = be16_to_cpu(rec->dlid);
1003         ah_attr->sl = rec->sl;
1004         ah_attr->src_path_bits = be16_to_cpu(rec->slid) &
1005                                  get_src_path_mask(device, port_num);
1006         ah_attr->port_num = port_num;
1007         ah_attr->static_rate = rec->rate;
1008
1009         force_grh = rdma_cap_eth_ah(device, port_num);
1010
1011         if (rec->hop_limit > 1 || force_grh) {
1012                 struct net_device *ndev = ib_get_ndev_from_path(rec);
1013
1014                 ah_attr->ah_flags = IB_AH_GRH;
1015                 ah_attr->grh.dgid = rec->dgid;
1016
1017                 ret = ib_find_cached_gid(device, &rec->sgid, ndev, &port_num,
1018                                          &gid_index);
1019                 if (ret) {
1020                         if (ndev)
1021                                 dev_put(ndev);
1022                         return ret;
1023                 }
1024
1025                 ah_attr->grh.sgid_index    = gid_index;
1026                 ah_attr->grh.flow_label    = be32_to_cpu(rec->flow_label);
1027                 ah_attr->grh.hop_limit     = rec->hop_limit;
1028                 ah_attr->grh.traffic_class = rec->traffic_class;
1029                 if (ndev)
1030                         dev_put(ndev);
1031         }
1032         if (force_grh) {
1033                 memcpy(ah_attr->dmac, rec->dmac, ETH_ALEN);
1034         }
1035         return 0;
1036 }
1037 EXPORT_SYMBOL(ib_init_ah_from_path);
1038
1039 static int alloc_mad(struct ib_sa_query *query, gfp_t gfp_mask)
1040 {
1041         unsigned long flags;
1042
1043         spin_lock_irqsave(&query->port->ah_lock, flags);
1044         if (!query->port->sm_ah) {
1045                 spin_unlock_irqrestore(&query->port->ah_lock, flags);
1046                 return -EAGAIN;
1047         }
1048         kref_get(&query->port->sm_ah->ref);
1049         query->sm_ah = query->port->sm_ah;
1050         spin_unlock_irqrestore(&query->port->ah_lock, flags);
1051
1052         query->mad_buf = ib_create_send_mad(query->port->agent, 1,
1053                                             query->sm_ah->pkey_index,
1054                                             0, IB_MGMT_SA_HDR, IB_MGMT_SA_DATA,
1055                                             gfp_mask,
1056                                             IB_MGMT_BASE_VERSION);
1057         if (IS_ERR(query->mad_buf)) {
1058                 kref_put(&query->sm_ah->ref, free_sm_ah);
1059                 return -ENOMEM;
1060         }
1061
1062         query->mad_buf->ah = query->sm_ah->ah;
1063
1064         return 0;
1065 }
1066
1067 static void free_mad(struct ib_sa_query *query)
1068 {
1069         ib_free_send_mad(query->mad_buf);
1070         kref_put(&query->sm_ah->ref, free_sm_ah);
1071 }
1072
1073 static void init_mad(struct ib_sa_mad *mad, struct ib_mad_agent *agent)
1074 {
1075         unsigned long flags;
1076
1077         memset(mad, 0, sizeof *mad);
1078
1079         mad->mad_hdr.base_version  = IB_MGMT_BASE_VERSION;
1080         mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_SUBN_ADM;
1081         mad->mad_hdr.class_version = IB_SA_CLASS_VERSION;
1082
1083         spin_lock_irqsave(&tid_lock, flags);
1084         mad->mad_hdr.tid           =
1085                 cpu_to_be64(((u64) agent->hi_tid) << 32 | tid++);
1086         spin_unlock_irqrestore(&tid_lock, flags);
1087 }
1088
1089 static int send_mad(struct ib_sa_query *query, int timeout_ms, gfp_t gfp_mask)
1090 {
1091         bool preload = gfpflags_allow_blocking(gfp_mask);
1092         unsigned long flags;
1093         int ret, id;
1094
1095         if (preload)
1096                 idr_preload(gfp_mask);
1097         spin_lock_irqsave(&idr_lock, flags);
1098
1099         id = idr_alloc(&query_idr, query, 0, 0, GFP_NOWAIT);
1100
1101         spin_unlock_irqrestore(&idr_lock, flags);
1102         if (preload)
1103                 idr_preload_end();
1104         if (id < 0)
1105                 return id;
1106
1107         query->mad_buf->timeout_ms  = timeout_ms;
1108         query->mad_buf->context[0] = query;
1109         query->id = id;
1110
1111         if (query->flags & IB_SA_ENABLE_LOCAL_SERVICE) {
1112                 if (!ibnl_chk_listeners(RDMA_NL_GROUP_LS)) {
1113                         if (!ib_nl_make_request(query, gfp_mask))
1114                                 return id;
1115                 }
1116                 ib_sa_disable_local_svc(query);
1117         }
1118
1119         ret = ib_post_send_mad(query->mad_buf, NULL);
1120         if (ret) {
1121                 spin_lock_irqsave(&idr_lock, flags);
1122                 idr_remove(&query_idr, id);
1123                 spin_unlock_irqrestore(&idr_lock, flags);
1124         }
1125
1126         /*
1127          * It's not safe to dereference query any more, because the
1128          * send may already have completed and freed the query in
1129          * another context.
1130          */
1131         return ret ? ret : id;
1132 }
1133
1134 void ib_sa_unpack_path(void *attribute, struct ib_sa_path_rec *rec)
1135 {
1136         ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table), attribute, rec);
1137 }
1138 EXPORT_SYMBOL(ib_sa_unpack_path);
1139
1140 void ib_sa_pack_path(struct ib_sa_path_rec *rec, void *attribute)
1141 {
1142         ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, attribute);
1143 }
1144 EXPORT_SYMBOL(ib_sa_pack_path);
1145
1146 static void ib_sa_path_rec_callback(struct ib_sa_query *sa_query,
1147                                     int status,
1148                                     struct ib_sa_mad *mad)
1149 {
1150         struct ib_sa_path_query *query =
1151                 container_of(sa_query, struct ib_sa_path_query, sa_query);
1152
1153         if (mad) {
1154                 struct ib_sa_path_rec rec;
1155
1156                 ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table),
1157                           mad->data, &rec);
1158                 rec.net = NULL;
1159                 rec.ifindex = 0;
1160                 memset(rec.dmac, 0, ETH_ALEN);
1161                 query->callback(status, &rec, query->context);
1162         } else
1163                 query->callback(status, NULL, query->context);
1164 }
1165
1166 static void ib_sa_path_rec_release(struct ib_sa_query *sa_query)
1167 {
1168         kfree(container_of(sa_query, struct ib_sa_path_query, sa_query));
1169 }
1170
1171 /**
1172  * ib_sa_path_rec_get - Start a Path get query
1173  * @client:SA client
1174  * @device:device to send query on
1175  * @port_num: port number to send query on
1176  * @rec:Path Record to send in query
1177  * @comp_mask:component mask to send in query
1178  * @timeout_ms:time to wait for response
1179  * @gfp_mask:GFP mask to use for internal allocations
1180  * @callback:function called when query completes, times out or is
1181  * canceled
1182  * @context:opaque user context passed to callback
1183  * @sa_query:query context, used to cancel query
1184  *
1185  * Send a Path Record Get query to the SA to look up a path.  The
1186  * callback function will be called when the query completes (or
1187  * fails); status is 0 for a successful response, -EINTR if the query
1188  * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1189  * occurred sending the query.  The resp parameter of the callback is
1190  * only valid if status is 0.
1191  *
1192  * If the return value of ib_sa_path_rec_get() is negative, it is an
1193  * error code.  Otherwise it is a query ID that can be used to cancel
1194  * the query.
1195  */
1196 int ib_sa_path_rec_get(struct ib_sa_client *client,
1197                        struct ib_device *device, u8 port_num,
1198                        struct ib_sa_path_rec *rec,
1199                        ib_sa_comp_mask comp_mask,
1200                        int timeout_ms, gfp_t gfp_mask,
1201                        void (*callback)(int status,
1202                                         struct ib_sa_path_rec *resp,
1203                                         void *context),
1204                        void *context,
1205                        struct ib_sa_query **sa_query)
1206 {
1207         struct ib_sa_path_query *query;
1208         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1209         struct ib_sa_port   *port;
1210         struct ib_mad_agent *agent;
1211         struct ib_sa_mad *mad;
1212         int ret;
1213
1214         if (!sa_dev)
1215                 return -ENODEV;
1216
1217         port  = &sa_dev->port[port_num - sa_dev->start_port];
1218         agent = port->agent;
1219
1220         query = kzalloc(sizeof(*query), gfp_mask);
1221         if (!query)
1222                 return -ENOMEM;
1223
1224         query->sa_query.port     = port;
1225         ret = alloc_mad(&query->sa_query, gfp_mask);
1226         if (ret)
1227                 goto err1;
1228
1229         ib_sa_client_get(client);
1230         query->sa_query.client = client;
1231         query->callback        = callback;
1232         query->context         = context;
1233
1234         mad = query->sa_query.mad_buf->mad;
1235         init_mad(mad, agent);
1236
1237         query->sa_query.callback = callback ? ib_sa_path_rec_callback : NULL;
1238         query->sa_query.release  = ib_sa_path_rec_release;
1239         mad->mad_hdr.method      = IB_MGMT_METHOD_GET;
1240         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_PATH_REC);
1241         mad->sa_hdr.comp_mask    = comp_mask;
1242
1243         ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, mad->data);
1244
1245         *sa_query = &query->sa_query;
1246
1247         query->sa_query.flags |= IB_SA_ENABLE_LOCAL_SERVICE;
1248         query->sa_query.mad_buf->context[1] = rec;
1249
1250         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1251         if (ret < 0)
1252                 goto err2;
1253
1254         return ret;
1255
1256 err2:
1257         *sa_query = NULL;
1258         ib_sa_client_put(query->sa_query.client);
1259         free_mad(&query->sa_query);
1260
1261 err1:
1262         kfree(query);
1263         return ret;
1264 }
1265 EXPORT_SYMBOL(ib_sa_path_rec_get);
1266
1267 static void ib_sa_service_rec_callback(struct ib_sa_query *sa_query,
1268                                     int status,
1269                                     struct ib_sa_mad *mad)
1270 {
1271         struct ib_sa_service_query *query =
1272                 container_of(sa_query, struct ib_sa_service_query, sa_query);
1273
1274         if (mad) {
1275                 struct ib_sa_service_rec rec;
1276
1277                 ib_unpack(service_rec_table, ARRAY_SIZE(service_rec_table),
1278                           mad->data, &rec);
1279                 query->callback(status, &rec, query->context);
1280         } else
1281                 query->callback(status, NULL, query->context);
1282 }
1283
1284 static void ib_sa_service_rec_release(struct ib_sa_query *sa_query)
1285 {
1286         kfree(container_of(sa_query, struct ib_sa_service_query, sa_query));
1287 }
1288
1289 /**
1290  * ib_sa_service_rec_query - Start Service Record operation
1291  * @client:SA client
1292  * @device:device to send request on
1293  * @port_num: port number to send request on
1294  * @method:SA method - should be get, set, or delete
1295  * @rec:Service Record to send in request
1296  * @comp_mask:component mask to send in request
1297  * @timeout_ms:time to wait for response
1298  * @gfp_mask:GFP mask to use for internal allocations
1299  * @callback:function called when request completes, times out or is
1300  * canceled
1301  * @context:opaque user context passed to callback
1302  * @sa_query:request context, used to cancel request
1303  *
1304  * Send a Service Record set/get/delete to the SA to register,
1305  * unregister or query a service record.
1306  * The callback function will be called when the request completes (or
1307  * fails); status is 0 for a successful response, -EINTR if the query
1308  * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1309  * occurred sending the query.  The resp parameter of the callback is
1310  * only valid if status is 0.
1311  *
1312  * If the return value of ib_sa_service_rec_query() is negative, it is an
1313  * error code.  Otherwise it is a request ID that can be used to cancel
1314  * the query.
1315  */
1316 int ib_sa_service_rec_query(struct ib_sa_client *client,
1317                             struct ib_device *device, u8 port_num, u8 method,
1318                             struct ib_sa_service_rec *rec,
1319                             ib_sa_comp_mask comp_mask,
1320                             int timeout_ms, gfp_t gfp_mask,
1321                             void (*callback)(int status,
1322                                              struct ib_sa_service_rec *resp,
1323                                              void *context),
1324                             void *context,
1325                             struct ib_sa_query **sa_query)
1326 {
1327         struct ib_sa_service_query *query;
1328         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1329         struct ib_sa_port   *port;
1330         struct ib_mad_agent *agent;
1331         struct ib_sa_mad *mad;
1332         int ret;
1333
1334         if (!sa_dev)
1335                 return -ENODEV;
1336
1337         port  = &sa_dev->port[port_num - sa_dev->start_port];
1338         agent = port->agent;
1339
1340         if (method != IB_MGMT_METHOD_GET &&
1341             method != IB_MGMT_METHOD_SET &&
1342             method != IB_SA_METHOD_DELETE)
1343                 return -EINVAL;
1344
1345         query = kzalloc(sizeof(*query), gfp_mask);
1346         if (!query)
1347                 return -ENOMEM;
1348
1349         query->sa_query.port     = port;
1350         ret = alloc_mad(&query->sa_query, gfp_mask);
1351         if (ret)
1352                 goto err1;
1353
1354         ib_sa_client_get(client);
1355         query->sa_query.client = client;
1356         query->callback        = callback;
1357         query->context         = context;
1358
1359         mad = query->sa_query.mad_buf->mad;
1360         init_mad(mad, agent);
1361
1362         query->sa_query.callback = callback ? ib_sa_service_rec_callback : NULL;
1363         query->sa_query.release  = ib_sa_service_rec_release;
1364         mad->mad_hdr.method      = method;
1365         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_SERVICE_REC);
1366         mad->sa_hdr.comp_mask    = comp_mask;
1367
1368         ib_pack(service_rec_table, ARRAY_SIZE(service_rec_table),
1369                 rec, mad->data);
1370
1371         *sa_query = &query->sa_query;
1372
1373         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1374         if (ret < 0)
1375                 goto err2;
1376
1377         return ret;
1378
1379 err2:
1380         *sa_query = NULL;
1381         ib_sa_client_put(query->sa_query.client);
1382         free_mad(&query->sa_query);
1383
1384 err1:
1385         kfree(query);
1386         return ret;
1387 }
1388 EXPORT_SYMBOL(ib_sa_service_rec_query);
1389
1390 static void ib_sa_mcmember_rec_callback(struct ib_sa_query *sa_query,
1391                                         int status,
1392                                         struct ib_sa_mad *mad)
1393 {
1394         struct ib_sa_mcmember_query *query =
1395                 container_of(sa_query, struct ib_sa_mcmember_query, sa_query);
1396
1397         if (mad) {
1398                 struct ib_sa_mcmember_rec rec;
1399
1400                 ib_unpack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
1401                           mad->data, &rec);
1402                 query->callback(status, &rec, query->context);
1403         } else
1404                 query->callback(status, NULL, query->context);
1405 }
1406
1407 static void ib_sa_mcmember_rec_release(struct ib_sa_query *sa_query)
1408 {
1409         kfree(container_of(sa_query, struct ib_sa_mcmember_query, sa_query));
1410 }
1411
1412 int ib_sa_mcmember_rec_query(struct ib_sa_client *client,
1413                              struct ib_device *device, u8 port_num,
1414                              u8 method,
1415                              struct ib_sa_mcmember_rec *rec,
1416                              ib_sa_comp_mask comp_mask,
1417                              int timeout_ms, gfp_t gfp_mask,
1418                              void (*callback)(int status,
1419                                               struct ib_sa_mcmember_rec *resp,
1420                                               void *context),
1421                              void *context,
1422                              struct ib_sa_query **sa_query)
1423 {
1424         struct ib_sa_mcmember_query *query;
1425         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1426         struct ib_sa_port   *port;
1427         struct ib_mad_agent *agent;
1428         struct ib_sa_mad *mad;
1429         int ret;
1430
1431         if (!sa_dev)
1432                 return -ENODEV;
1433
1434         port  = &sa_dev->port[port_num - sa_dev->start_port];
1435         agent = port->agent;
1436
1437         query = kzalloc(sizeof(*query), gfp_mask);
1438         if (!query)
1439                 return -ENOMEM;
1440
1441         query->sa_query.port     = port;
1442         ret = alloc_mad(&query->sa_query, gfp_mask);
1443         if (ret)
1444                 goto err1;
1445
1446         ib_sa_client_get(client);
1447         query->sa_query.client = client;
1448         query->callback        = callback;
1449         query->context         = context;
1450
1451         mad = query->sa_query.mad_buf->mad;
1452         init_mad(mad, agent);
1453
1454         query->sa_query.callback = callback ? ib_sa_mcmember_rec_callback : NULL;
1455         query->sa_query.release  = ib_sa_mcmember_rec_release;
1456         mad->mad_hdr.method      = method;
1457         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
1458         mad->sa_hdr.comp_mask    = comp_mask;
1459
1460         ib_pack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
1461                 rec, mad->data);
1462
1463         *sa_query = &query->sa_query;
1464
1465         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1466         if (ret < 0)
1467                 goto err2;
1468
1469         return ret;
1470
1471 err2:
1472         *sa_query = NULL;
1473         ib_sa_client_put(query->sa_query.client);
1474         free_mad(&query->sa_query);
1475
1476 err1:
1477         kfree(query);
1478         return ret;
1479 }
1480
1481 /* Support GuidInfoRecord */
1482 static void ib_sa_guidinfo_rec_callback(struct ib_sa_query *sa_query,
1483                                         int status,
1484                                         struct ib_sa_mad *mad)
1485 {
1486         struct ib_sa_guidinfo_query *query =
1487                 container_of(sa_query, struct ib_sa_guidinfo_query, sa_query);
1488
1489         if (mad) {
1490                 struct ib_sa_guidinfo_rec rec;
1491
1492                 ib_unpack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table),
1493                           mad->data, &rec);
1494                 query->callback(status, &rec, query->context);
1495         } else
1496                 query->callback(status, NULL, query->context);
1497 }
1498
1499 static void ib_sa_guidinfo_rec_release(struct ib_sa_query *sa_query)
1500 {
1501         kfree(container_of(sa_query, struct ib_sa_guidinfo_query, sa_query));
1502 }
1503
1504 int ib_sa_guid_info_rec_query(struct ib_sa_client *client,
1505                               struct ib_device *device, u8 port_num,
1506                               struct ib_sa_guidinfo_rec *rec,
1507                               ib_sa_comp_mask comp_mask, u8 method,
1508                               int timeout_ms, gfp_t gfp_mask,
1509                               void (*callback)(int status,
1510                                                struct ib_sa_guidinfo_rec *resp,
1511                                                void *context),
1512                               void *context,
1513                               struct ib_sa_query **sa_query)
1514 {
1515         struct ib_sa_guidinfo_query *query;
1516         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1517         struct ib_sa_port *port;
1518         struct ib_mad_agent *agent;
1519         struct ib_sa_mad *mad;
1520         int ret;
1521
1522         if (!sa_dev)
1523                 return -ENODEV;
1524
1525         if (method != IB_MGMT_METHOD_GET &&
1526             method != IB_MGMT_METHOD_SET &&
1527             method != IB_SA_METHOD_DELETE) {
1528                 return -EINVAL;
1529         }
1530
1531         port  = &sa_dev->port[port_num - sa_dev->start_port];
1532         agent = port->agent;
1533
1534         query = kzalloc(sizeof(*query), gfp_mask);
1535         if (!query)
1536                 return -ENOMEM;
1537
1538         query->sa_query.port = port;
1539         ret = alloc_mad(&query->sa_query, gfp_mask);
1540         if (ret)
1541                 goto err1;
1542
1543         ib_sa_client_get(client);
1544         query->sa_query.client = client;
1545         query->callback        = callback;
1546         query->context         = context;
1547
1548         mad = query->sa_query.mad_buf->mad;
1549         init_mad(mad, agent);
1550
1551         query->sa_query.callback = callback ? ib_sa_guidinfo_rec_callback : NULL;
1552         query->sa_query.release  = ib_sa_guidinfo_rec_release;
1553
1554         mad->mad_hdr.method      = method;
1555         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_GUID_INFO_REC);
1556         mad->sa_hdr.comp_mask    = comp_mask;
1557
1558         ib_pack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table), rec,
1559                 mad->data);
1560
1561         *sa_query = &query->sa_query;
1562
1563         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1564         if (ret < 0)
1565                 goto err2;
1566
1567         return ret;
1568
1569 err2:
1570         *sa_query = NULL;
1571         ib_sa_client_put(query->sa_query.client);
1572         free_mad(&query->sa_query);
1573
1574 err1:
1575         kfree(query);
1576         return ret;
1577 }
1578 EXPORT_SYMBOL(ib_sa_guid_info_rec_query);
1579
1580 static void send_handler(struct ib_mad_agent *agent,
1581                          struct ib_mad_send_wc *mad_send_wc)
1582 {
1583         struct ib_sa_query *query = mad_send_wc->send_buf->context[0];
1584         unsigned long flags;
1585
1586         if (query->callback)
1587                 switch (mad_send_wc->status) {
1588                 case IB_WC_SUCCESS:
1589                         /* No callback -- already got recv */
1590                         break;
1591                 case IB_WC_RESP_TIMEOUT_ERR:
1592                         query->callback(query, -ETIMEDOUT, NULL);
1593                         break;
1594                 case IB_WC_WR_FLUSH_ERR:
1595                         query->callback(query, -EINTR, NULL);
1596                         break;
1597                 default:
1598                         query->callback(query, -EIO, NULL);
1599                         break;
1600                 }
1601
1602         spin_lock_irqsave(&idr_lock, flags);
1603         idr_remove(&query_idr, query->id);
1604         spin_unlock_irqrestore(&idr_lock, flags);
1605
1606         free_mad(query);
1607         ib_sa_client_put(query->client);
1608         query->release(query);
1609 }
1610
1611 static void recv_handler(struct ib_mad_agent *mad_agent,
1612                          struct ib_mad_recv_wc *mad_recv_wc)
1613 {
1614         struct ib_sa_query *query;
1615         struct ib_mad_send_buf *mad_buf;
1616
1617         mad_buf = (void *) (unsigned long) mad_recv_wc->wc->wr_id;
1618         query = mad_buf->context[0];
1619
1620         if (query->callback) {
1621                 if (mad_recv_wc->wc->status == IB_WC_SUCCESS)
1622                         query->callback(query,
1623                                         mad_recv_wc->recv_buf.mad->mad_hdr.status ?
1624                                         -EINVAL : 0,
1625                                         (struct ib_sa_mad *) mad_recv_wc->recv_buf.mad);
1626                 else
1627                         query->callback(query, -EIO, NULL);
1628         }
1629
1630         ib_free_recv_mad(mad_recv_wc);
1631 }
1632
1633 static void ib_sa_add_one(struct ib_device *device)
1634 {
1635         struct ib_sa_device *sa_dev;
1636         int s, e, i;
1637         int count = 0;
1638
1639         s = rdma_start_port(device);
1640         e = rdma_end_port(device);
1641
1642         sa_dev = kzalloc(sizeof *sa_dev +
1643                          (e - s + 1) * sizeof (struct ib_sa_port),
1644                          GFP_KERNEL);
1645         if (!sa_dev)
1646                 return;
1647
1648         sa_dev->start_port = s;
1649         sa_dev->end_port   = e;
1650
1651         for (i = 0; i <= e - s; ++i) {
1652                 spin_lock_init(&sa_dev->port[i].ah_lock);
1653                 if (!rdma_cap_ib_sa(device, i + 1))
1654                         continue;
1655
1656                 sa_dev->port[i].sm_ah    = NULL;
1657                 sa_dev->port[i].port_num = i + s;
1658
1659                 sa_dev->port[i].agent =
1660                         ib_register_mad_agent(device, i + s, IB_QPT_GSI,
1661                                               NULL, 0, send_handler,
1662                                               recv_handler, sa_dev, 0);
1663                 if (IS_ERR(sa_dev->port[i].agent))
1664                         goto err;
1665
1666                 INIT_WORK(&sa_dev->port[i].update_task, update_sm_ah);
1667
1668                 count++;
1669         }
1670
1671         if (!count)
1672                 goto free;
1673
1674         ib_set_client_data(device, &sa_client, sa_dev);
1675
1676         /*
1677          * We register our event handler after everything is set up,
1678          * and then update our cached info after the event handler is
1679          * registered to avoid any problems if a port changes state
1680          * during our initialization.
1681          */
1682
1683         INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);
1684         if (ib_register_event_handler(&sa_dev->event_handler))
1685                 goto err;
1686
1687         for (i = 0; i <= e - s; ++i) {
1688                 if (rdma_cap_ib_sa(device, i + 1))
1689                         update_sm_ah(&sa_dev->port[i].update_task);
1690         }
1691
1692         return;
1693
1694 err:
1695         while (--i >= 0) {
1696                 if (rdma_cap_ib_sa(device, i + 1))
1697                         ib_unregister_mad_agent(sa_dev->port[i].agent);
1698         }
1699 free:
1700         kfree(sa_dev);
1701         return;
1702 }
1703
1704 static void ib_sa_remove_one(struct ib_device *device, void *client_data)
1705 {
1706         struct ib_sa_device *sa_dev = client_data;
1707         int i;
1708
1709         if (!sa_dev)
1710                 return;
1711
1712         ib_unregister_event_handler(&sa_dev->event_handler);
1713
1714         flush_workqueue(ib_wq);
1715
1716         for (i = 0; i <= sa_dev->end_port - sa_dev->start_port; ++i) {
1717                 if (rdma_cap_ib_sa(device, i + 1)) {
1718                         ib_unregister_mad_agent(sa_dev->port[i].agent);
1719                         if (sa_dev->port[i].sm_ah)
1720                                 kref_put(&sa_dev->port[i].sm_ah->ref, free_sm_ah);
1721                 }
1722
1723         }
1724
1725         kfree(sa_dev);
1726 }
1727
1728 static int __init ib_sa_init(void)
1729 {
1730         int ret;
1731
1732         get_random_bytes(&tid, sizeof tid);
1733
1734         atomic_set(&ib_nl_sa_request_seq, 0);
1735
1736         ret = ib_register_client(&sa_client);
1737         if (ret) {
1738                 printk(KERN_ERR "Couldn't register ib_sa client\n");
1739                 goto err1;
1740         }
1741
1742         ret = mcast_init();
1743         if (ret) {
1744                 printk(KERN_ERR "Couldn't initialize multicast handling\n");
1745                 goto err2;
1746         }
1747
1748         ib_nl_wq = create_singlethread_workqueue("ib_nl_sa_wq");
1749         if (!ib_nl_wq) {
1750                 ret = -ENOMEM;
1751                 goto err3;
1752         }
1753
1754         if (ibnl_add_client(RDMA_NL_LS, RDMA_NL_LS_NUM_OPS,
1755                             ib_sa_cb_table)) {
1756                 pr_err("Failed to add netlink callback\n");
1757                 ret = -EINVAL;
1758                 goto err4;
1759         }
1760         INIT_DELAYED_WORK(&ib_nl_timed_work, ib_nl_request_timeout);
1761
1762         return 0;
1763 err4:
1764         destroy_workqueue(ib_nl_wq);
1765 err3:
1766         mcast_cleanup();
1767 err2:
1768         ib_unregister_client(&sa_client);
1769 err1:
1770         return ret;
1771 }
1772
1773 static void __exit ib_sa_cleanup(void)
1774 {
1775         ibnl_remove_client(RDMA_NL_LS);
1776         cancel_delayed_work(&ib_nl_timed_work);
1777         flush_workqueue(ib_nl_wq);
1778         destroy_workqueue(ib_nl_wq);
1779         mcast_cleanup();
1780         ib_unregister_client(&sa_client);
1781         idr_destroy(&query_idr);
1782 }
1783
1784 module_init(ib_sa_init);
1785 module_exit(ib_sa_cleanup);