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)
 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_KERNEL);
 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_KERNEL);
 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)
 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         spin_lock_irqsave(&ib_nl_request_lock, flags);
 566         ret = ib_nl_send_msg(query);
 567         if (ret <= 0) {
 568                 ret = -EIO;
 569                 goto request_out;
 570         } else {
 571                 ret = 0;
 572         }
 573
 574         delay = msecs_to_jiffies(sa_local_svc_timeout_ms);
 575         query->timeout = delay + jiffies;
 576         list_add_tail(&query->list, &ib_nl_request_list);
 577         /* Start the timeout if this is the only request */
 578         if (ib_nl_request_list.next == &query->list)
 579                 queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay);
 580
 581 request_out:
 582         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 583
 584         return ret;
 585 }
 586
 587 static int ib_nl_cancel_request(struct ib_sa_query *query)
 588 {
 589         unsigned long flags;
 590         struct ib_sa_query *wait_query;
 591         int found = 0;
 592
 593         spin_lock_irqsave(&ib_nl_request_lock, flags);
 594         list_for_each_entry(wait_query, &ib_nl_request_list, list) {
 595                 /* Let the timeout to take care of the callback */
 596                 if (query == wait_query) {
 597                         query->flags |= IB_SA_CANCEL;
 598                         query->timeout = jiffies;
 599                         list_move(&query->list, &ib_nl_request_list);
 600                         found = 1;
 601                         mod_delayed_work(ib_nl_wq, &ib_nl_timed_work, 1);
 602                         break;
 603                 }
 604         }
 605         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 606
 607         return found;
 608 }
 609
 610 static void send_handler(struct ib_mad_agent *agent,
 611                          struct ib_mad_send_wc *mad_send_wc);
 612
 613 static void ib_nl_process_good_resolve_rsp(struct ib_sa_query *query,
 614                                            const struct nlmsghdr *nlh)
 615 {
 616         struct ib_mad_send_wc mad_send_wc;
 617         struct ib_sa_mad *mad = NULL;
 618         const struct nlattr *head, *curr;
 619         struct ib_path_rec_data  *rec;
 620         int len, rem;
 621         u32 mask = 0;
 622         int status = -EIO;
 623
 624         if (query->callback) {
 625                 head = (const struct nlattr *) nlmsg_data(nlh);
 626                 len = nlmsg_len(nlh);
 627                 switch (query->path_use) {
 628                 case LS_RESOLVE_PATH_USE_UNIDIRECTIONAL:
 629                         mask = IB_PATH_PRIMARY | IB_PATH_OUTBOUND;
 630                         break;
 631
 632                 case LS_RESOLVE_PATH_USE_ALL:
 633                 case LS_RESOLVE_PATH_USE_GMP:
 634                 default:
 635                         mask = IB_PATH_PRIMARY | IB_PATH_GMP |
 636                                 IB_PATH_BIDIRECTIONAL;
 637                         break;
 638                 }
 639                 nla_for_each_attr(curr, head, len, rem) {
 640                         if (curr->nla_type == LS_NLA_TYPE_PATH_RECORD) {
 641                                 rec = nla_data(curr);
 642                                 /*
 643                                  * Get the first one. In the future, we may
 644                                  * need to get up to 6 pathrecords.
 645                                  */
 646                                 if ((rec->flags & mask) == mask) {
 647                                         mad = query->mad_buf->mad;
 648                                         mad->mad_hdr.method |=
 649                                                 IB_MGMT_METHOD_RESP;
 650                                         memcpy(mad->data, rec->path_rec,
 651                                                sizeof(rec->path_rec));
 652                                         status = 0;
 653                                         break;
 654                                 }
 655                         }
 656                 }
 657                 query->callback(query, status, mad);
 658         }
 659
 660         mad_send_wc.send_buf = query->mad_buf;
 661         mad_send_wc.status = IB_WC_SUCCESS;
 662         send_handler(query->mad_buf->mad_agent, &mad_send_wc);
 663 }
 664
 665 static void ib_nl_request_timeout(struct work_struct *work)
 666 {
 667         unsigned long flags;
 668         struct ib_sa_query *query;
 669         unsigned long delay;
 670         struct ib_mad_send_wc mad_send_wc;
 671         int ret;
 672
 673         spin_lock_irqsave(&ib_nl_request_lock, flags);
 674         while (!list_empty(&ib_nl_request_list)) {
 675                 query = list_entry(ib_nl_request_list.next,
 676                                    struct ib_sa_query, list);
 677
 678                 if (time_after(query->timeout, jiffies)) {
 679                         delay = query->timeout - jiffies;
 680                         if ((long)delay <= 0)
 681                                 delay = 1;
 682                         queue_delayed_work(ib_nl_wq, &ib_nl_timed_work, delay);
 683                         break;
 684                 }
 685
 686                 list_del(&query->list);
 687                 ib_sa_disable_local_svc(query);
 688                 /* Hold the lock to protect against query cancellation */
 689                 if (ib_sa_query_cancelled(query))
 690                         ret = -1;
 691                 else
 692                         ret = ib_post_send_mad(query->mad_buf, NULL);
 693                 if (ret) {
 694                         mad_send_wc.send_buf = query->mad_buf;
 695                         mad_send_wc.status = IB_WC_WR_FLUSH_ERR;
 696                         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 697                         send_handler(query->port->agent, &mad_send_wc);
 698                         spin_lock_irqsave(&ib_nl_request_lock, flags);
 699                 }
 700         }
 701         spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 702 }
 703
 704 static int ib_nl_handle_set_timeout(struct sk_buff *skb,
 705                                     struct netlink_callback *cb)
 706 {
 707         const struct nlmsghdr *nlh = (struct nlmsghdr *)cb->nlh;
 708         int timeout, delta, abs_delta;
 709         const struct nlattr *attr;
 710         unsigned long flags;
 711         struct ib_sa_query *query;
 712         long delay = 0;
 713         struct nlattr *tb[LS_NLA_TYPE_MAX];
 714         int ret;
 715
 716         if (!netlink_capable(skb, CAP_NET_ADMIN))
 717                 return -EPERM;
 718
 719         ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh),
 720                         nlmsg_len(nlh), ib_nl_policy);
 721         attr = (const struct nlattr *)tb[LS_NLA_TYPE_TIMEOUT];
 722         if (ret || !attr)
 723                 goto settimeout_out;
 724
 725         timeout = *(int *) nla_data(attr);
 726         if (timeout < IB_SA_LOCAL_SVC_TIMEOUT_MIN)
 727                 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MIN;
 728         if (timeout > IB_SA_LOCAL_SVC_TIMEOUT_MAX)
 729                 timeout = IB_SA_LOCAL_SVC_TIMEOUT_MAX;
 730
 731         delta = timeout - sa_local_svc_timeout_ms;
 732         if (delta < 0)
 733                 abs_delta = -delta;
 734         else
 735                 abs_delta = delta;
 736
 737         if (delta != 0) {
 738                 spin_lock_irqsave(&ib_nl_request_lock, flags);
 739                 sa_local_svc_timeout_ms = timeout;
 740                 list_for_each_entry(query, &ib_nl_request_list, list) {
 741                         if (delta < 0 && abs_delta > query->timeout)
 742                                 query->timeout = 0;
 743                         else
 744                                 query->timeout += delta;
 745
 746                         /* Get the new delay from the first entry */
 747                         if (!delay) {
 748                                 delay = query->timeout - jiffies;
 749                                 if (delay <= 0)
 750                                         delay = 1;
 751                         }
 752                 }
 753                 if (delay)
 754                         mod_delayed_work(ib_nl_wq, &ib_nl_timed_work,
 755                                          (unsigned long)delay);
 756                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 757         }
 758
 759 settimeout_out:
 760         return skb->len;
 761 }
 762
 763 static inline int ib_nl_is_good_resolve_resp(const struct nlmsghdr *nlh)
 764 {
 765         struct nlattr *tb[LS_NLA_TYPE_MAX];
 766         int ret;
 767
 768         if (nlh->nlmsg_flags & RDMA_NL_LS_F_ERR)
 769                 return 0;
 770
 771         ret = nla_parse(tb, LS_NLA_TYPE_MAX - 1, nlmsg_data(nlh),
 772                         nlmsg_len(nlh), ib_nl_policy);
 773         if (ret)
 774                 return 0;
 775
 776         return 1;
 777 }
 778
 779 static int ib_nl_handle_resolve_resp(struct sk_buff *skb,
 780                                      struct netlink_callback *cb)
 781 {
 782         const struct nlmsghdr *nlh = (struct nlmsghdr *)cb->nlh;
 783         unsigned long flags;
 784         struct ib_sa_query *query;
 785         struct ib_mad_send_buf *send_buf;
 786         struct ib_mad_send_wc mad_send_wc;
 787         int found = 0;
 788         int ret;
 789
 790         if (!netlink_capable(skb, CAP_NET_ADMIN))
 791                 return -EPERM;
 792
 793         spin_lock_irqsave(&ib_nl_request_lock, flags);
 794         list_for_each_entry(query, &ib_nl_request_list, list) {
 795                 /*
 796                  * If the query is cancelled, let the timeout routine
 797                  * take care of it.
 798                  */
 799                 if (nlh->nlmsg_seq == query->seq) {
 800                         found = !ib_sa_query_cancelled(query);
 801                         if (found)
 802                                 list_del(&query->list);
 803                         break;
 804                 }
 805         }
 806
 807         if (!found) {
 808                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 809                 goto resp_out;
 810         }
 811
 812         send_buf = query->mad_buf;
 813
 814         if (!ib_nl_is_good_resolve_resp(nlh)) {
 815                 /* if the result is a failure, send out the packet via IB */
 816                 ib_sa_disable_local_svc(query);
 817                 ret = ib_post_send_mad(query->mad_buf, NULL);
 818                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 819                 if (ret) {
 820                         mad_send_wc.send_buf = send_buf;
 821                         mad_send_wc.status = IB_WC_GENERAL_ERR;
 822                         send_handler(query->port->agent, &mad_send_wc);
 823                 }
 824         } else {
 825                 spin_unlock_irqrestore(&ib_nl_request_lock, flags);
 826                 ib_nl_process_good_resolve_rsp(query, nlh);
 827         }
 828
 829 resp_out:
 830         return skb->len;
 831 }
 832
 833 static struct ibnl_client_cbs ib_sa_cb_table[] = {
 834         [RDMA_NL_LS_OP_RESOLVE] = {
 835                 .dump = ib_nl_handle_resolve_resp,
 836                 .module = THIS_MODULE },
 837         [RDMA_NL_LS_OP_SET_TIMEOUT] = {
 838                 .dump = ib_nl_handle_set_timeout,
 839                 .module = THIS_MODULE },
 840 };
 841
 842 static void free_sm_ah(struct kref *kref)
 843 {
 844         struct ib_sa_sm_ah *sm_ah = container_of(kref, struct ib_sa_sm_ah, ref);
 845
 846         ib_destroy_ah(sm_ah->ah);
 847         kfree(sm_ah);
 848 }
 849
 850 static void update_sm_ah(struct work_struct *work)
 851 {
 852         struct ib_sa_port *port =
 853                 container_of(work, struct ib_sa_port, update_task);
 854         struct ib_sa_sm_ah *new_ah;
 855         struct ib_port_attr port_attr;
 856         struct ib_ah_attr   ah_attr;
 857
 858         if (ib_query_port(port->agent->device, port->port_num, &port_attr)) {
 859                 printk(KERN_WARNING "Couldn't query port\n");
 860                 return;
 861         }
 862
 863         new_ah = kmalloc(sizeof *new_ah, GFP_KERNEL);
 864         if (!new_ah) {
 865                 printk(KERN_WARNING "Couldn't allocate new SM AH\n");
 866                 return;
 867         }
 868
 869         kref_init(&new_ah->ref);
 870         new_ah->src_path_mask = (1 << port_attr.lmc) - 1;
 871
 872         new_ah->pkey_index = 0;
 873         if (ib_find_pkey(port->agent->device, port->port_num,
 874                          IB_DEFAULT_PKEY_FULL, &new_ah->pkey_index))
 875                 printk(KERN_ERR "Couldn't find index for default PKey\n");
 876
 877         memset(&ah_attr, 0, sizeof ah_attr);
 878         ah_attr.dlid     = port_attr.sm_lid;
 879         ah_attr.sl       = port_attr.sm_sl;
 880         ah_attr.port_num = port->port_num;
 881
 882         new_ah->ah = ib_create_ah(port->agent->qp->pd, &ah_attr);
 883         if (IS_ERR(new_ah->ah)) {
 884                 printk(KERN_WARNING "Couldn't create new SM AH\n");
 885                 kfree(new_ah);
 886                 return;
 887         }
 888
 889         spin_lock_irq(&port->ah_lock);
 890         if (port->sm_ah)
 891                 kref_put(&port->sm_ah->ref, free_sm_ah);
 892         port->sm_ah = new_ah;
 893         spin_unlock_irq(&port->ah_lock);
 894
 895 }
 896
 897 static void ib_sa_event(struct ib_event_handler *handler, struct ib_event *event)
 898 {
 899         if (event->event == IB_EVENT_PORT_ERR    ||
 900             event->event == IB_EVENT_PORT_ACTIVE ||
 901             event->event == IB_EVENT_LID_CHANGE  ||
 902             event->event == IB_EVENT_PKEY_CHANGE ||
 903             event->event == IB_EVENT_SM_CHANGE   ||
 904             event->event == IB_EVENT_CLIENT_REREGISTER) {
 905                 unsigned long flags;
 906                 struct ib_sa_device *sa_dev =
 907                         container_of(handler, typeof(*sa_dev), event_handler);
 908                 struct ib_sa_port *port =
 909                         &sa_dev->port[event->element.port_num - sa_dev->start_port];
 910
 911                 if (!rdma_cap_ib_sa(handler->device, port->port_num))
 912                         return;
 913
 914                 spin_lock_irqsave(&port->ah_lock, flags);
 915                 if (port->sm_ah)
 916                         kref_put(&port->sm_ah->ref, free_sm_ah);
 917                 port->sm_ah = NULL;
 918                 spin_unlock_irqrestore(&port->ah_lock, flags);
 919
 920                 queue_work(ib_wq, &sa_dev->port[event->element.port_num -
 921                                             sa_dev->start_port].update_task);
 922         }
 923 }
 924
 925 void ib_sa_register_client(struct ib_sa_client *client)
 926 {
 927         atomic_set(&client->users, 1);
 928         init_completion(&client->comp);
 929 }
 930 EXPORT_SYMBOL(ib_sa_register_client);
 931
 932 void ib_sa_unregister_client(struct ib_sa_client *client)
 933 {
 934         ib_sa_client_put(client);
 935         wait_for_completion(&client->comp);
 936 }
 937 EXPORT_SYMBOL(ib_sa_unregister_client);
 938
 939 /**
 940  * ib_sa_cancel_query - try to cancel an SA query
 941  * @id:ID of query to cancel
 942  * @query:query pointer to cancel
 943  *
 944  * Try to cancel an SA query.  If the id and query don't match up or
 945  * the query has already completed, nothing is done.  Otherwise the
 946  * query is canceled and will complete with a status of -EINTR.
 947  */
 948 void ib_sa_cancel_query(int id, struct ib_sa_query *query)
 949 {
 950         unsigned long flags;
 951         struct ib_mad_agent *agent;
 952         struct ib_mad_send_buf *mad_buf;
 953
 954         spin_lock_irqsave(&idr_lock, flags);
 955         if (idr_find(&query_idr, id) != query) {
 956                 spin_unlock_irqrestore(&idr_lock, flags);
 957                 return;
 958         }
 959         agent = query->port->agent;
 960         mad_buf = query->mad_buf;
 961         spin_unlock_irqrestore(&idr_lock, flags);
 962
 963         /*
 964          * If the query is still on the netlink request list, schedule
 965          * it to be cancelled by the timeout routine. Otherwise, it has been
 966          * sent to the MAD layer and has to be cancelled from there.
 967          */
 968         if (!ib_nl_cancel_request(query))
 969                 ib_cancel_mad(agent, mad_buf);
 970 }
 971 EXPORT_SYMBOL(ib_sa_cancel_query);
 972
 973 static u8 get_src_path_mask(struct ib_device *device, u8 port_num)
 974 {
 975         struct ib_sa_device *sa_dev;
 976         struct ib_sa_port   *port;
 977         unsigned long flags;
 978         u8 src_path_mask;
 979
 980         sa_dev = ib_get_client_data(device, &sa_client);
 981         if (!sa_dev)
 982                 return 0x7f;
 983
 984         port  = &sa_dev->port[port_num - sa_dev->start_port];
 985         spin_lock_irqsave(&port->ah_lock, flags);
 986         src_path_mask = port->sm_ah ? port->sm_ah->src_path_mask : 0x7f;
 987         spin_unlock_irqrestore(&port->ah_lock, flags);
 988
 989         return src_path_mask;
 990 }
 991
 992 int ib_init_ah_from_path(struct ib_device *device, u8 port_num,
 993                          struct ib_sa_path_rec *rec, struct ib_ah_attr *ah_attr)
 994 {
 995         int ret;
 996         u16 gid_index;
 997         int force_grh;
 998
 999         memset(ah_attr, 0, sizeof *ah_attr);
1000         ah_attr->dlid = be16_to_cpu(rec->dlid);
1001         ah_attr->sl = rec->sl;
1002         ah_attr->src_path_bits = be16_to_cpu(rec->slid) &
1003                                  get_src_path_mask(device, port_num);
1004         ah_attr->port_num = port_num;
1005         ah_attr->static_rate = rec->rate;
1006
1007         force_grh = rdma_cap_eth_ah(device, port_num);
1008
1009         if (rec->hop_limit > 1 || force_grh) {
1010                 struct net_device *ndev = ib_get_ndev_from_path(rec);
1011
1012                 ah_attr->ah_flags = IB_AH_GRH;
1013                 ah_attr->grh.dgid = rec->dgid;
1014
1015                 ret = ib_find_cached_gid(device, &rec->sgid, ndev, &port_num,
1016                                          &gid_index);
1017                 if (ret) {
1018                         if (ndev)
1019                                 dev_put(ndev);
1020                         return ret;
1021                 }
1022
1023                 ah_attr->grh.sgid_index    = gid_index;
1024                 ah_attr->grh.flow_label    = be32_to_cpu(rec->flow_label);
1025                 ah_attr->grh.hop_limit     = rec->hop_limit;
1026                 ah_attr->grh.traffic_class = rec->traffic_class;
1027                 if (ndev)
1028                         dev_put(ndev);
1029         }
1030         if (force_grh) {
1031                 memcpy(ah_attr->dmac, rec->dmac, ETH_ALEN);
1032         }
1033         return 0;
1034 }
1035 EXPORT_SYMBOL(ib_init_ah_from_path);
1036
1037 static int alloc_mad(struct ib_sa_query *query, gfp_t gfp_mask)
1038 {
1039         unsigned long flags;
1040
1041         spin_lock_irqsave(&query->port->ah_lock, flags);
1042         if (!query->port->sm_ah) {
1043                 spin_unlock_irqrestore(&query->port->ah_lock, flags);
1044                 return -EAGAIN;
1045         }
1046         kref_get(&query->port->sm_ah->ref);
1047         query->sm_ah = query->port->sm_ah;
1048         spin_unlock_irqrestore(&query->port->ah_lock, flags);
1049
1050         query->mad_buf = ib_create_send_mad(query->port->agent, 1,
1051                                             query->sm_ah->pkey_index,
1052                                             0, IB_MGMT_SA_HDR, IB_MGMT_SA_DATA,
1053                                             gfp_mask,
1054                                             IB_MGMT_BASE_VERSION);
1055         if (IS_ERR(query->mad_buf)) {
1056                 kref_put(&query->sm_ah->ref, free_sm_ah);
1057                 return -ENOMEM;
1058         }
1059
1060         query->mad_buf->ah = query->sm_ah->ah;
1061
1062         return 0;
1063 }
1064
1065 static void free_mad(struct ib_sa_query *query)
1066 {
1067         ib_free_send_mad(query->mad_buf);
1068         kref_put(&query->sm_ah->ref, free_sm_ah);
1069 }
1070
1071 static void init_mad(struct ib_sa_mad *mad, struct ib_mad_agent *agent)
1072 {
1073         unsigned long flags;
1074
1075         memset(mad, 0, sizeof *mad);
1076
1077         mad->mad_hdr.base_version  = IB_MGMT_BASE_VERSION;
1078         mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_SUBN_ADM;
1079         mad->mad_hdr.class_version = IB_SA_CLASS_VERSION;
1080
1081         spin_lock_irqsave(&tid_lock, flags);
1082         mad->mad_hdr.tid           =
1083                 cpu_to_be64(((u64) agent->hi_tid) << 32 | tid++);
1084         spin_unlock_irqrestore(&tid_lock, flags);
1085 }
1086
1087 static int send_mad(struct ib_sa_query *query, int timeout_ms, gfp_t gfp_mask)
1088 {
1089         bool preload = gfpflags_allow_blocking(gfp_mask);
1090         unsigned long flags;
1091         int ret, id;
1092
1093         if (preload)
1094                 idr_preload(gfp_mask);
1095         spin_lock_irqsave(&idr_lock, flags);
1096
1097         id = idr_alloc(&query_idr, query, 0, 0, GFP_NOWAIT);
1098
1099         spin_unlock_irqrestore(&idr_lock, flags);
1100         if (preload)
1101                 idr_preload_end();
1102         if (id < 0)
1103                 return id;
1104
1105         query->mad_buf->timeout_ms  = timeout_ms;
1106         query->mad_buf->context[0] = query;
1107         query->id = id;
1108
1109         if (query->flags & IB_SA_ENABLE_LOCAL_SERVICE) {
1110                 if (!ibnl_chk_listeners(RDMA_NL_GROUP_LS)) {
1111                         if (!ib_nl_make_request(query))
1112                                 return id;
1113                 }
1114                 ib_sa_disable_local_svc(query);
1115         }
1116
1117         ret = ib_post_send_mad(query->mad_buf, NULL);
1118         if (ret) {
1119                 spin_lock_irqsave(&idr_lock, flags);
1120                 idr_remove(&query_idr, id);
1121                 spin_unlock_irqrestore(&idr_lock, flags);
1122         }
1123
1124         /*
1125          * It's not safe to dereference query any more, because the
1126          * send may already have completed and freed the query in
1127          * another context.
1128          */
1129         return ret ? ret : id;
1130 }
1131
1132 void ib_sa_unpack_path(void *attribute, struct ib_sa_path_rec *rec)
1133 {
1134         ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table), attribute, rec);
1135 }
1136 EXPORT_SYMBOL(ib_sa_unpack_path);
1137
1138 void ib_sa_pack_path(struct ib_sa_path_rec *rec, void *attribute)
1139 {
1140         ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, attribute);
1141 }
1142 EXPORT_SYMBOL(ib_sa_pack_path);
1143
1144 static void ib_sa_path_rec_callback(struct ib_sa_query *sa_query,
1145                                     int status,
1146                                     struct ib_sa_mad *mad)
1147 {
1148         struct ib_sa_path_query *query =
1149                 container_of(sa_query, struct ib_sa_path_query, sa_query);
1150
1151         if (mad) {
1152                 struct ib_sa_path_rec rec;
1153
1154                 ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table),
1155                           mad->data, &rec);
1156                 rec.net = NULL;
1157                 rec.ifindex = 0;
1158                 memset(rec.dmac, 0, ETH_ALEN);
1159                 query->callback(status, &rec, query->context);
1160         } else
1161                 query->callback(status, NULL, query->context);
1162 }
1163
1164 static void ib_sa_path_rec_release(struct ib_sa_query *sa_query)
1165 {
1166         kfree(container_of(sa_query, struct ib_sa_path_query, sa_query));
1167 }
1168
1169 /**
1170  * ib_sa_path_rec_get - Start a Path get query
1171  * @client:SA client
1172  * @device:device to send query on
1173  * @port_num: port number to send query on
1174  * @rec:Path Record to send in query
1175  * @comp_mask:component mask to send in query
1176  * @timeout_ms:time to wait for response
1177  * @gfp_mask:GFP mask to use for internal allocations
1178  * @callback:function called when query completes, times out or is
1179  * canceled
1180  * @context:opaque user context passed to callback
1181  * @sa_query:query context, used to cancel query
1182  *
1183  * Send a Path Record Get query to the SA to look up a path.  The
1184  * callback function will be called when the query completes (or
1185  * fails); status is 0 for a successful response, -EINTR if the query
1186  * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1187  * occurred sending the query.  The resp parameter of the callback is
1188  * only valid if status is 0.
1189  *
1190  * If the return value of ib_sa_path_rec_get() is negative, it is an
1191  * error code.  Otherwise it is a query ID that can be used to cancel
1192  * the query.
1193  */
1194 int ib_sa_path_rec_get(struct ib_sa_client *client,
1195                        struct ib_device *device, u8 port_num,
1196                        struct ib_sa_path_rec *rec,
1197                        ib_sa_comp_mask comp_mask,
1198                        int timeout_ms, gfp_t gfp_mask,
1199                        void (*callback)(int status,
1200                                         struct ib_sa_path_rec *resp,
1201                                         void *context),
1202                        void *context,
1203                        struct ib_sa_query **sa_query)
1204 {
1205         struct ib_sa_path_query *query;
1206         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1207         struct ib_sa_port   *port;
1208         struct ib_mad_agent *agent;
1209         struct ib_sa_mad *mad;
1210         int ret;
1211
1212         if (!sa_dev)
1213                 return -ENODEV;
1214
1215         port  = &sa_dev->port[port_num - sa_dev->start_port];
1216         agent = port->agent;
1217
1218         query = kzalloc(sizeof(*query), gfp_mask);
1219         if (!query)
1220                 return -ENOMEM;
1221
1222         query->sa_query.port     = port;
1223         ret = alloc_mad(&query->sa_query, gfp_mask);
1224         if (ret)
1225                 goto err1;
1226
1227         ib_sa_client_get(client);
1228         query->sa_query.client = client;
1229         query->callback        = callback;
1230         query->context         = context;
1231
1232         mad = query->sa_query.mad_buf->mad;
1233         init_mad(mad, agent);
1234
1235         query->sa_query.callback = callback ? ib_sa_path_rec_callback : NULL;
1236         query->sa_query.release  = ib_sa_path_rec_release;
1237         mad->mad_hdr.method      = IB_MGMT_METHOD_GET;
1238         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_PATH_REC);
1239         mad->sa_hdr.comp_mask    = comp_mask;
1240
1241         ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, mad->data);
1242
1243         *sa_query = &query->sa_query;
1244
1245         query->sa_query.flags |= IB_SA_ENABLE_LOCAL_SERVICE;
1246         query->sa_query.mad_buf->context[1] = rec;
1247
1248         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1249         if (ret < 0)
1250                 goto err2;
1251
1252         return ret;
1253
1254 err2:
1255         *sa_query = NULL;
1256         ib_sa_client_put(query->sa_query.client);
1257         free_mad(&query->sa_query);
1258
1259 err1:
1260         kfree(query);
1261         return ret;
1262 }
1263 EXPORT_SYMBOL(ib_sa_path_rec_get);
1264
1265 static void ib_sa_service_rec_callback(struct ib_sa_query *sa_query,
1266                                     int status,
1267                                     struct ib_sa_mad *mad)
1268 {
1269         struct ib_sa_service_query *query =
1270                 container_of(sa_query, struct ib_sa_service_query, sa_query);
1271
1272         if (mad) {
1273                 struct ib_sa_service_rec rec;
1274
1275                 ib_unpack(service_rec_table, ARRAY_SIZE(service_rec_table),
1276                           mad->data, &rec);
1277                 query->callback(status, &rec, query->context);
1278         } else
1279                 query->callback(status, NULL, query->context);
1280 }
1281
1282 static void ib_sa_service_rec_release(struct ib_sa_query *sa_query)
1283 {
1284         kfree(container_of(sa_query, struct ib_sa_service_query, sa_query));
1285 }
1286
1287 /**
1288  * ib_sa_service_rec_query - Start Service Record operation
1289  * @client:SA client
1290  * @device:device to send request on
1291  * @port_num: port number to send request on
1292  * @method:SA method - should be get, set, or delete
1293  * @rec:Service Record to send in request
1294  * @comp_mask:component mask to send in request
1295  * @timeout_ms:time to wait for response
1296  * @gfp_mask:GFP mask to use for internal allocations
1297  * @callback:function called when request completes, times out or is
1298  * canceled
1299  * @context:opaque user context passed to callback
1300  * @sa_query:request context, used to cancel request
1301  *
1302  * Send a Service Record set/get/delete to the SA to register,
1303  * unregister or query a service record.
1304  * The callback function will be called when the request completes (or
1305  * fails); status is 0 for a successful response, -EINTR if the query
1306  * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
1307  * occurred sending the query.  The resp parameter of the callback is
1308  * only valid if status is 0.
1309  *
1310  * If the return value of ib_sa_service_rec_query() is negative, it is an
1311  * error code.  Otherwise it is a request ID that can be used to cancel
1312  * the query.
1313  */
1314 int ib_sa_service_rec_query(struct ib_sa_client *client,
1315                             struct ib_device *device, u8 port_num, u8 method,
1316                             struct ib_sa_service_rec *rec,
1317                             ib_sa_comp_mask comp_mask,
1318                             int timeout_ms, gfp_t gfp_mask,
1319                             void (*callback)(int status,
1320                                              struct ib_sa_service_rec *resp,
1321                                              void *context),
1322                             void *context,
1323                             struct ib_sa_query **sa_query)
1324 {
1325         struct ib_sa_service_query *query;
1326         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1327         struct ib_sa_port   *port;
1328         struct ib_mad_agent *agent;
1329         struct ib_sa_mad *mad;
1330         int ret;
1331
1332         if (!sa_dev)
1333                 return -ENODEV;
1334
1335         port  = &sa_dev->port[port_num - sa_dev->start_port];
1336         agent = port->agent;
1337
1338         if (method != IB_MGMT_METHOD_GET &&
1339             method != IB_MGMT_METHOD_SET &&
1340             method != IB_SA_METHOD_DELETE)
1341                 return -EINVAL;
1342
1343         query = kzalloc(sizeof(*query), gfp_mask);
1344         if (!query)
1345                 return -ENOMEM;
1346
1347         query->sa_query.port     = port;
1348         ret = alloc_mad(&query->sa_query, gfp_mask);
1349         if (ret)
1350                 goto err1;
1351
1352         ib_sa_client_get(client);
1353         query->sa_query.client = client;
1354         query->callback        = callback;
1355         query->context         = context;
1356
1357         mad = query->sa_query.mad_buf->mad;
1358         init_mad(mad, agent);
1359
1360         query->sa_query.callback = callback ? ib_sa_service_rec_callback : NULL;
1361         query->sa_query.release  = ib_sa_service_rec_release;
1362         mad->mad_hdr.method      = method;
1363         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_SERVICE_REC);
1364         mad->sa_hdr.comp_mask    = comp_mask;
1365
1366         ib_pack(service_rec_table, ARRAY_SIZE(service_rec_table),
1367                 rec, mad->data);
1368
1369         *sa_query = &query->sa_query;
1370
1371         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1372         if (ret < 0)
1373                 goto err2;
1374
1375         return ret;
1376
1377 err2:
1378         *sa_query = NULL;
1379         ib_sa_client_put(query->sa_query.client);
1380         free_mad(&query->sa_query);
1381
1382 err1:
1383         kfree(query);
1384         return ret;
1385 }
1386 EXPORT_SYMBOL(ib_sa_service_rec_query);
1387
1388 static void ib_sa_mcmember_rec_callback(struct ib_sa_query *sa_query,
1389                                         int status,
1390                                         struct ib_sa_mad *mad)
1391 {
1392         struct ib_sa_mcmember_query *query =
1393                 container_of(sa_query, struct ib_sa_mcmember_query, sa_query);
1394
1395         if (mad) {
1396                 struct ib_sa_mcmember_rec rec;
1397
1398                 ib_unpack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
1399                           mad->data, &rec);
1400                 query->callback(status, &rec, query->context);
1401         } else
1402                 query->callback(status, NULL, query->context);
1403 }
1404
1405 static void ib_sa_mcmember_rec_release(struct ib_sa_query *sa_query)
1406 {
1407         kfree(container_of(sa_query, struct ib_sa_mcmember_query, sa_query));
1408 }
1409
1410 int ib_sa_mcmember_rec_query(struct ib_sa_client *client,
1411                              struct ib_device *device, u8 port_num,
1412                              u8 method,
1413                              struct ib_sa_mcmember_rec *rec,
1414                              ib_sa_comp_mask comp_mask,
1415                              int timeout_ms, gfp_t gfp_mask,
1416                              void (*callback)(int status,
1417                                               struct ib_sa_mcmember_rec *resp,
1418                                               void *context),
1419                              void *context,
1420                              struct ib_sa_query **sa_query)
1421 {
1422         struct ib_sa_mcmember_query *query;
1423         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1424         struct ib_sa_port   *port;
1425         struct ib_mad_agent *agent;
1426         struct ib_sa_mad *mad;
1427         int ret;
1428
1429         if (!sa_dev)
1430                 return -ENODEV;
1431
1432         port  = &sa_dev->port[port_num - sa_dev->start_port];
1433         agent = port->agent;
1434
1435         query = kzalloc(sizeof(*query), gfp_mask);
1436         if (!query)
1437                 return -ENOMEM;
1438
1439         query->sa_query.port     = port;
1440         ret = alloc_mad(&query->sa_query, gfp_mask);
1441         if (ret)
1442                 goto err1;
1443
1444         ib_sa_client_get(client);
1445         query->sa_query.client = client;
1446         query->callback        = callback;
1447         query->context         = context;
1448
1449         mad = query->sa_query.mad_buf->mad;
1450         init_mad(mad, agent);
1451
1452         query->sa_query.callback = callback ? ib_sa_mcmember_rec_callback : NULL;
1453         query->sa_query.release  = ib_sa_mcmember_rec_release;
1454         mad->mad_hdr.method      = method;
1455         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
1456         mad->sa_hdr.comp_mask    = comp_mask;
1457
1458         ib_pack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
1459                 rec, mad->data);
1460
1461         *sa_query = &query->sa_query;
1462
1463         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1464         if (ret < 0)
1465                 goto err2;
1466
1467         return ret;
1468
1469 err2:
1470         *sa_query = NULL;
1471         ib_sa_client_put(query->sa_query.client);
1472         free_mad(&query->sa_query);
1473
1474 err1:
1475         kfree(query);
1476         return ret;
1477 }
1478
1479 /* Support GuidInfoRecord */
1480 static void ib_sa_guidinfo_rec_callback(struct ib_sa_query *sa_query,
1481                                         int status,
1482                                         struct ib_sa_mad *mad)
1483 {
1484         struct ib_sa_guidinfo_query *query =
1485                 container_of(sa_query, struct ib_sa_guidinfo_query, sa_query);
1486
1487         if (mad) {
1488                 struct ib_sa_guidinfo_rec rec;
1489
1490                 ib_unpack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table),
1491                           mad->data, &rec);
1492                 query->callback(status, &rec, query->context);
1493         } else
1494                 query->callback(status, NULL, query->context);
1495 }
1496
1497 static void ib_sa_guidinfo_rec_release(struct ib_sa_query *sa_query)
1498 {
1499         kfree(container_of(sa_query, struct ib_sa_guidinfo_query, sa_query));
1500 }
1501
1502 int ib_sa_guid_info_rec_query(struct ib_sa_client *client,
1503                               struct ib_device *device, u8 port_num,
1504                               struct ib_sa_guidinfo_rec *rec,
1505                               ib_sa_comp_mask comp_mask, u8 method,
1506                               int timeout_ms, gfp_t gfp_mask,
1507                               void (*callback)(int status,
1508                                                struct ib_sa_guidinfo_rec *resp,
1509                                                void *context),
1510                               void *context,
1511                               struct ib_sa_query **sa_query)
1512 {
1513         struct ib_sa_guidinfo_query *query;
1514         struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1515         struct ib_sa_port *port;
1516         struct ib_mad_agent *agent;
1517         struct ib_sa_mad *mad;
1518         int ret;
1519
1520         if (!sa_dev)
1521                 return -ENODEV;
1522
1523         if (method != IB_MGMT_METHOD_GET &&
1524             method != IB_MGMT_METHOD_SET &&
1525             method != IB_SA_METHOD_DELETE) {
1526                 return -EINVAL;
1527         }
1528
1529         port  = &sa_dev->port[port_num - sa_dev->start_port];
1530         agent = port->agent;
1531
1532         query = kzalloc(sizeof(*query), gfp_mask);
1533         if (!query)
1534                 return -ENOMEM;
1535
1536         query->sa_query.port = port;
1537         ret = alloc_mad(&query->sa_query, gfp_mask);
1538         if (ret)
1539                 goto err1;
1540
1541         ib_sa_client_get(client);
1542         query->sa_query.client = client;
1543         query->callback        = callback;
1544         query->context         = context;
1545
1546         mad = query->sa_query.mad_buf->mad;
1547         init_mad(mad, agent);
1548
1549         query->sa_query.callback = callback ? ib_sa_guidinfo_rec_callback : NULL;
1550         query->sa_query.release  = ib_sa_guidinfo_rec_release;
1551
1552         mad->mad_hdr.method      = method;
1553         mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_GUID_INFO_REC);
1554         mad->sa_hdr.comp_mask    = comp_mask;
1555
1556         ib_pack(guidinfo_rec_table, ARRAY_SIZE(guidinfo_rec_table), rec,
1557                 mad->data);
1558
1559         *sa_query = &query->sa_query;
1560
1561         ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
1562         if (ret < 0)
1563                 goto err2;
1564
1565         return ret;
1566
1567 err2:
1568         *sa_query = NULL;
1569         ib_sa_client_put(query->sa_query.client);
1570         free_mad(&query->sa_query);
1571
1572 err1:
1573         kfree(query);
1574         return ret;
1575 }
1576 EXPORT_SYMBOL(ib_sa_guid_info_rec_query);
1577
1578 static void send_handler(struct ib_mad_agent *agent,
1579                          struct ib_mad_send_wc *mad_send_wc)
1580 {
1581         struct ib_sa_query *query = mad_send_wc->send_buf->context[0];
1582         unsigned long flags;
1583
1584         if (query->callback)
1585                 switch (mad_send_wc->status) {
1586                 case IB_WC_SUCCESS:
1587                         /* No callback -- already got recv */
1588                         break;
1589                 case IB_WC_RESP_TIMEOUT_ERR:
1590                         query->callback(query, -ETIMEDOUT, NULL);
1591                         break;
1592                 case IB_WC_WR_FLUSH_ERR:
1593                         query->callback(query, -EINTR, NULL);
1594                         break;
1595                 default:
1596                         query->callback(query, -EIO, NULL);
1597                         break;
1598                 }
1599
1600         spin_lock_irqsave(&idr_lock, flags);
1601         idr_remove(&query_idr, query->id);
1602         spin_unlock_irqrestore(&idr_lock, flags);
1603
1604         free_mad(query);
1605         ib_sa_client_put(query->client);
1606         query->release(query);
1607 }
1608
1609 static void recv_handler(struct ib_mad_agent *mad_agent,
1610                          struct ib_mad_recv_wc *mad_recv_wc)
1611 {
1612         struct ib_sa_query *query;
1613         struct ib_mad_send_buf *mad_buf;
1614
1615         mad_buf = (void *) (unsigned long) mad_recv_wc->wc->wr_id;
1616         query = mad_buf->context[0];
1617
1618         if (query->callback) {
1619                 if (mad_recv_wc->wc->status == IB_WC_SUCCESS)
1620                         query->callback(query,
1621                                         mad_recv_wc->recv_buf.mad->mad_hdr.status ?
1622                                         -EINVAL : 0,
1623                                         (struct ib_sa_mad *) mad_recv_wc->recv_buf.mad);
1624                 else
1625                         query->callback(query, -EIO, NULL);
1626         }
1627
1628         ib_free_recv_mad(mad_recv_wc);
1629 }
1630
1631 static void ib_sa_add_one(struct ib_device *device)
1632 {
1633         struct ib_sa_device *sa_dev;
1634         int s, e, i;
1635         int count = 0;
1636
1637         s = rdma_start_port(device);
1638         e = rdma_end_port(device);
1639
1640         sa_dev = kzalloc(sizeof *sa_dev +
1641                          (e - s + 1) * sizeof (struct ib_sa_port),
1642                          GFP_KERNEL);
1643         if (!sa_dev)
1644                 return;
1645
1646         sa_dev->start_port = s;
1647         sa_dev->end_port   = e;
1648
1649         for (i = 0; i <= e - s; ++i) {
1650                 spin_lock_init(&sa_dev->port[i].ah_lock);
1651                 if (!rdma_cap_ib_sa(device, i + 1))
1652                         continue;
1653
1654                 sa_dev->port[i].sm_ah    = NULL;
1655                 sa_dev->port[i].port_num = i + s;
1656
1657                 sa_dev->port[i].agent =
1658                         ib_register_mad_agent(device, i + s, IB_QPT_GSI,
1659                                               NULL, 0, send_handler,
1660                                               recv_handler, sa_dev, 0);
1661                 if (IS_ERR(sa_dev->port[i].agent))
1662                         goto err;
1663
1664                 INIT_WORK(&sa_dev->port[i].update_task, update_sm_ah);
1665
1666                 count++;
1667         }
1668
1669         if (!count)
1670                 goto free;
1671
1672         ib_set_client_data(device, &sa_client, sa_dev);
1673
1674         /*
1675          * We register our event handler after everything is set up,
1676          * and then update our cached info after the event handler is
1677          * registered to avoid any problems if a port changes state
1678          * during our initialization.
1679          */
1680
1681         INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);
1682         if (ib_register_event_handler(&sa_dev->event_handler))
1683                 goto err;
1684
1685         for (i = 0; i <= e - s; ++i) {
1686                 if (rdma_cap_ib_sa(device, i + 1))
1687                         update_sm_ah(&sa_dev->port[i].update_task);
1688         }
1689
1690         return;
1691
1692 err:
1693         while (--i >= 0) {
1694                 if (rdma_cap_ib_sa(device, i + 1))
1695                         ib_unregister_mad_agent(sa_dev->port[i].agent);
1696         }
1697 free:
1698         kfree(sa_dev);
1699         return;
1700 }
1701
1702 static void ib_sa_remove_one(struct ib_device *device, void *client_data)
1703 {
1704         struct ib_sa_device *sa_dev = client_data;
1705         int i;
1706
1707         if (!sa_dev)
1708                 return;
1709
1710         ib_unregister_event_handler(&sa_dev->event_handler);
1711
1712         flush_workqueue(ib_wq);
1713
1714         for (i = 0; i <= sa_dev->end_port - sa_dev->start_port; ++i) {
1715                 if (rdma_cap_ib_sa(device, i + 1)) {
1716                         ib_unregister_mad_agent(sa_dev->port[i].agent);
1717                         if (sa_dev->port[i].sm_ah)
1718                                 kref_put(&sa_dev->port[i].sm_ah->ref, free_sm_ah);
1719                 }
1720
1721         }
1722
1723         kfree(sa_dev);
1724 }
1725
1726 static int __init ib_sa_init(void)
1727 {
1728         int ret;
1729
1730         get_random_bytes(&tid, sizeof tid);
1731
1732         atomic_set(&ib_nl_sa_request_seq, 0);
1733
1734         ret = ib_register_client(&sa_client);
1735         if (ret) {
1736                 printk(KERN_ERR "Couldn't register ib_sa client\n");
1737                 goto err1;
1738         }
1739
1740         ret = mcast_init();
1741         if (ret) {
1742                 printk(KERN_ERR "Couldn't initialize multicast handling\n");
1743                 goto err2;
1744         }
1745
1746         ib_nl_wq = create_singlethread_workqueue("ib_nl_sa_wq");
1747         if (!ib_nl_wq) {
1748                 ret = -ENOMEM;
1749                 goto err3;
1750         }
1751
1752         if (ibnl_add_client(RDMA_NL_LS, RDMA_NL_LS_NUM_OPS,
1753                             ib_sa_cb_table)) {
1754                 pr_err("Failed to add netlink callback\n");
1755                 ret = -EINVAL;
1756                 goto err4;
1757         }
1758         INIT_DELAYED_WORK(&ib_nl_timed_work, ib_nl_request_timeout);
1759
1760         return 0;
1761 err4:
1762         destroy_workqueue(ib_nl_wq);
1763 err3:
1764         mcast_cleanup();
1765 err2:
1766         ib_unregister_client(&sa_client);
1767 err1:
1768         return ret;
1769 }
1770
1771 static void __exit ib_sa_cleanup(void)
1772 {
1773         ibnl_remove_client(RDMA_NL_LS);
1774         cancel_delayed_work(&ib_nl_timed_work);
1775         flush_workqueue(ib_nl_wq);
1776         destroy_workqueue(ib_nl_wq);
1777         mcast_cleanup();
1778         ib_unregister_client(&sa_client);
1779         idr_destroy(&query_idr);
1780 }
1781
1782 module_init(ib_sa_init);
1783 module_exit(ib_sa_cleanup);