linux/drivers/infiniband/core/sa_query.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2004 Topspin Communications.  All rights reserved.
   3 * Copyright (c) 2005 Voltaire, Inc.  All rights reserved.
   4 * Copyright (c) 2006 Intel Corporation.  All rights reserved.
   5 *
   6 * This software is available to you under a choice of one of two
   7 * licenses.  You may choose to be licensed under the terms of the GNU
   8 * General Public License (GPL) Version 2, available from the file
   9 * COPYING in the main directory of this source tree, or the
  10 * OpenIB.org BSD license below:
  11 *
  12 *     Redistribution and use in source and binary forms, with or
  13 *     without modification, are permitted provided that the following
  14 *     conditions are met:
  15 *
  16 *      - Redistributions of source code must retain the above
  17 *        copyright notice, this list of conditions and the following
  18 *        disclaimer.
  19 *
  20 *      - Redistributions in binary form must reproduce the above
  21 *        copyright notice, this list of conditions and the following
  22 *        disclaimer in the documentation and/or other materials
  23 *        provided with the distribution.
  24 *
  25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  32 * SOFTWARE.
  33 *
  34 * $Id: sa_query.c 2811 2005-07-06 18:11:43Z halr $
  35 */
  36
  37#include <linux/module.h>
  38#include <linux/init.h>
  39#include <linux/err.h>
  40#include <linux/random.h>
  41#include <linux/spinlock.h>
  42#include <linux/slab.h>
  43#include <linux/dma-mapping.h>
  44#include <linux/kref.h>
  45#include <linux/idr.h>
  46#include <linux/workqueue.h>
  47
  48#include <rdma/ib_pack.h>
  49#include <rdma/ib_cache.h>
  50#include "sa.h"
  51
  52MODULE_AUTHOR("Roland Dreier");
  53MODULE_DESCRIPTION("InfiniBand subnet administration query support");
  54MODULE_LICENSE("Dual BSD/GPL");
  55
  56struct ib_sa_sm_ah {
  57        struct ib_ah        *ah;
  58        struct kref          ref;
  59        u16                  pkey_index;
  60        u8                   src_path_mask;
  61};
  62
  63struct ib_sa_port {
  64        struct ib_mad_agent *agent;
  65        struct ib_sa_sm_ah  *sm_ah;
  66        struct work_struct   update_task;
  67        spinlock_t           ah_lock;
  68        u8                   port_num;
  69};
  70
  71struct ib_sa_device {
  72        int                     start_port, end_port;
  73        struct ib_event_handler event_handler;
  74        struct ib_sa_port port[0];
  75};
  76
  77struct ib_sa_query {
  78        void (*callback)(struct ib_sa_query *, int, struct ib_sa_mad *);
  79        void (*release)(struct ib_sa_query *);
  80        struct ib_sa_client    *client;
  81        struct ib_sa_port      *port;
  82        struct ib_mad_send_buf *mad_buf;
  83        struct ib_sa_sm_ah     *sm_ah;
  84        int                     id;
  85};
  86
  87struct ib_sa_service_query {
  88        void (*callback)(int, struct ib_sa_service_rec *, void *);
  89        void *context;
  90        struct ib_sa_query sa_query;
  91};
  92
  93struct ib_sa_path_query {
  94        void (*callback)(int, struct ib_sa_path_rec *, void *);
  95        void *context;
  96        struct ib_sa_query sa_query;
  97};
  98
  99struct ib_sa_mcmember_query {
 100        void (*callback)(int, struct ib_sa_mcmember_rec *, void *);
 101        void *context;
 102        struct ib_sa_query sa_query;
 103};
 104
 105static void ib_sa_add_one(struct ib_device *device);
 106static void ib_sa_remove_one(struct ib_device *device);
 107
 108static struct ib_client sa_client = {
 109        .name   = "sa",
 110        .add    = ib_sa_add_one,
 111        .remove = ib_sa_remove_one
 112};
 113
 114static spinlock_t idr_lock;
 115static DEFINE_IDR(query_idr);
 116
 117static spinlock_t tid_lock;
 118static u32 tid;
 119
 120#define PATH_REC_FIELD(field) \
 121        .struct_offset_bytes = offsetof(struct ib_sa_path_rec, field),          \
 122        .struct_size_bytes   = sizeof ((struct ib_sa_path_rec *) 0)->field,     \
 123        .field_name          = "sa_path_rec:" #field
 124
 125static const struct ib_field path_rec_table[] = {
 126        { PATH_REC_FIELD(service_id),
 127          .offset_words = 0,
 128          .offset_bits  = 0,
 129          .size_bits    = 64 },
 130        { PATH_REC_FIELD(dgid),
 131          .offset_words = 2,
 132          .offset_bits  = 0,
 133          .size_bits    = 128 },
 134        { PATH_REC_FIELD(sgid),
 135          .offset_words = 6,
 136          .offset_bits  = 0,
 137          .size_bits    = 128 },
 138        { PATH_REC_FIELD(dlid),
 139          .offset_words = 10,
 140          .offset_bits  = 0,
 141          .size_bits    = 16 },
 142        { PATH_REC_FIELD(slid),
 143          .offset_words = 10,
 144          .offset_bits  = 16,
 145          .size_bits    = 16 },
 146        { PATH_REC_FIELD(raw_traffic),
 147          .offset_words = 11,
 148          .offset_bits  = 0,
 149          .size_bits    = 1 },
 150        { RESERVED,
 151          .offset_words = 11,
 152          .offset_bits  = 1,
 153          .size_bits    = 3 },
 154        { PATH_REC_FIELD(flow_label),
 155          .offset_words = 11,
 156          .offset_bits  = 4,
 157          .size_bits    = 20 },
 158        { PATH_REC_FIELD(hop_limit),
 159          .offset_words = 11,
 160          .offset_bits  = 24,
 161          .size_bits    = 8 },
 162        { PATH_REC_FIELD(traffic_class),
 163          .offset_words = 12,
 164          .offset_bits  = 0,
 165          .size_bits    = 8 },
 166        { PATH_REC_FIELD(reversible),
 167          .offset_words = 12,
 168          .offset_bits  = 8,
 169          .size_bits    = 1 },
 170        { PATH_REC_FIELD(numb_path),
 171          .offset_words = 12,
 172          .offset_bits  = 9,
 173          .size_bits    = 7 },
 174        { PATH_REC_FIELD(pkey),
 175          .offset_words = 12,
 176          .offset_bits  = 16,
 177          .size_bits    = 16 },
 178        { PATH_REC_FIELD(qos_class),
 179          .offset_words = 13,
 180          .offset_bits  = 0,
 181          .size_bits    = 12 },
 182        { PATH_REC_FIELD(sl),
 183          .offset_words = 13,
 184          .offset_bits  = 12,
 185          .size_bits    = 4 },
 186        { PATH_REC_FIELD(mtu_selector),
 187          .offset_words = 13,
 188          .offset_bits  = 16,
 189          .size_bits    = 2 },
 190        { PATH_REC_FIELD(mtu),
 191          .offset_words = 13,
 192          .offset_bits  = 18,
 193          .size_bits    = 6 },
 194        { PATH_REC_FIELD(rate_selector),
 195          .offset_words = 13,
 196          .offset_bits  = 24,
 197          .size_bits    = 2 },
 198        { PATH_REC_FIELD(rate),
 199          .offset_words = 13,
 200          .offset_bits  = 26,
 201          .size_bits    = 6 },
 202        { PATH_REC_FIELD(packet_life_time_selector),
 203          .offset_words = 14,
 204          .offset_bits  = 0,
 205          .size_bits    = 2 },
 206        { PATH_REC_FIELD(packet_life_time),
 207          .offset_words = 14,
 208          .offset_bits  = 2,
 209          .size_bits    = 6 },
 210        { PATH_REC_FIELD(preference),
 211          .offset_words = 14,
 212          .offset_bits  = 8,
 213          .size_bits    = 8 },
 214        { RESERVED,
 215          .offset_words = 14,
 216          .offset_bits  = 16,
 217          .size_bits    = 48 },
 218};
 219
 220#define MCMEMBER_REC_FIELD(field) \
 221        .struct_offset_bytes = offsetof(struct ib_sa_mcmember_rec, field),      \
 222        .struct_size_bytes   = sizeof ((struct ib_sa_mcmember_rec *) 0)->field, \
 223        .field_name          = "sa_mcmember_rec:" #field
 224
 225static const struct ib_field mcmember_rec_table[] = {
 226        { MCMEMBER_REC_FIELD(mgid),
 227          .offset_words = 0,
 228          .offset_bits  = 0,
 229          .size_bits    = 128 },
 230        { MCMEMBER_REC_FIELD(port_gid),
 231          .offset_words = 4,
 232          .offset_bits  = 0,
 233          .size_bits    = 128 },
 234        { MCMEMBER_REC_FIELD(qkey),
 235          .offset_words = 8,
 236          .offset_bits  = 0,
 237          .size_bits    = 32 },
 238        { MCMEMBER_REC_FIELD(mlid),
 239          .offset_words = 9,
 240          .offset_bits  = 0,
 241          .size_bits    = 16 },
 242        { MCMEMBER_REC_FIELD(mtu_selector),
 243          .offset_words = 9,
 244          .offset_bits  = 16,
 245          .size_bits    = 2 },
 246        { MCMEMBER_REC_FIELD(mtu),
 247          .offset_words = 9,
 248          .offset_bits  = 18,
 249          .size_bits    = 6 },
 250        { MCMEMBER_REC_FIELD(traffic_class),
 251          .offset_words = 9,
 252          .offset_bits  = 24,
 253          .size_bits    = 8 },
 254        { MCMEMBER_REC_FIELD(pkey),
 255          .offset_words = 10,
 256          .offset_bits  = 0,
 257          .size_bits    = 16 },
 258        { MCMEMBER_REC_FIELD(rate_selector),
 259          .offset_words = 10,
 260          .offset_bits  = 16,
 261          .size_bits    = 2 },
 262        { MCMEMBER_REC_FIELD(rate),
 263          .offset_words = 10,
 264          .offset_bits  = 18,
 265          .size_bits    = 6 },
 266        { MCMEMBER_REC_FIELD(packet_life_time_selector),
 267          .offset_words = 10,
 268          .offset_bits  = 24,
 269          .size_bits    = 2 },
 270        { MCMEMBER_REC_FIELD(packet_life_time),
 271          .offset_words = 10,
 272          .offset_bits  = 26,
 273          .size_bits    = 6 },
 274        { MCMEMBER_REC_FIELD(sl),
 275          .offset_words = 11,
 276          .offset_bits  = 0,
 277          .size_bits    = 4 },
 278        { MCMEMBER_REC_FIELD(flow_label),
 279          .offset_words = 11,
 280          .offset_bits  = 4,
 281          .size_bits    = 20 },
 282        { MCMEMBER_REC_FIELD(hop_limit),
 283          .offset_words = 11,
 284          .offset_bits  = 24,
 285          .size_bits    = 8 },
 286        { MCMEMBER_REC_FIELD(scope),
 287          .offset_words = 12,
 288          .offset_bits  = 0,
 289          .size_bits    = 4 },
 290        { MCMEMBER_REC_FIELD(join_state),
 291          .offset_words = 12,
 292          .offset_bits  = 4,
 293          .size_bits    = 4 },
 294        { MCMEMBER_REC_FIELD(proxy_join),
 295          .offset_words = 12,
 296          .offset_bits  = 8,
 297          .size_bits    = 1 },
 298        { RESERVED,
 299          .offset_words = 12,
 300          .offset_bits  = 9,
 301          .size_bits    = 23 },
 302};
 303
 304#define SERVICE_REC_FIELD(field) \
 305        .struct_offset_bytes = offsetof(struct ib_sa_service_rec, field),       \
 306        .struct_size_bytes   = sizeof ((struct ib_sa_service_rec *) 0)->field,  \
 307        .field_name          = "sa_service_rec:" #field
 308
 309static const struct ib_field service_rec_table[] = {
 310        { SERVICE_REC_FIELD(id),
 311          .offset_words = 0,
 312          .offset_bits  = 0,
 313          .size_bits    = 64 },
 314        { SERVICE_REC_FIELD(gid),
 315          .offset_words = 2,
 316          .offset_bits  = 0,
 317          .size_bits    = 128 },
 318        { SERVICE_REC_FIELD(pkey),
 319          .offset_words = 6,
 320          .offset_bits  = 0,
 321          .size_bits    = 16 },
 322        { SERVICE_REC_FIELD(lease),
 323          .offset_words = 7,
 324          .offset_bits  = 0,
 325          .size_bits    = 32 },
 326        { SERVICE_REC_FIELD(key),
 327          .offset_words = 8,
 328          .offset_bits  = 0,
 329          .size_bits    = 128 },
 330        { SERVICE_REC_FIELD(name),
 331          .offset_words = 12,
 332          .offset_bits  = 0,
 333          .size_bits    = 64*8 },
 334        { SERVICE_REC_FIELD(data8),
 335          .offset_words = 28,
 336          .offset_bits  = 0,
 337          .size_bits    = 16*8 },
 338        { SERVICE_REC_FIELD(data16),
 339          .offset_words = 32,
 340          .offset_bits  = 0,
 341          .size_bits    = 8*16 },
 342        { SERVICE_REC_FIELD(data32),
 343          .offset_words = 36,
 344          .offset_bits  = 0,
 345          .size_bits    = 4*32 },
 346        { SERVICE_REC_FIELD(data64),
 347          .offset_words = 40,
 348          .offset_bits  = 0,
 349          .size_bits    = 2*64 },
 350};
 351
 352static void free_sm_ah(struct kref *kref)
 353{
 354        struct ib_sa_sm_ah *sm_ah = container_of(kref, struct ib_sa_sm_ah, ref);
 355
 356        ib_destroy_ah(sm_ah->ah);
 357        kfree(sm_ah);
 358}
 359
 360static void update_sm_ah(struct work_struct *work)
 361{
 362        struct ib_sa_port *port =
 363                container_of(work, struct ib_sa_port, update_task);
 364        struct ib_sa_sm_ah *new_ah, *old_ah;
 365        struct ib_port_attr port_attr;
 366        struct ib_ah_attr   ah_attr;
 367
 368        if (ib_query_port(port->agent->device, port->port_num, &port_attr)) {
 369                printk(KERN_WARNING "Couldn't query port\n");
 370                return;
 371        }
 372
 373        new_ah = kmalloc(sizeof *new_ah, GFP_KERNEL);
 374        if (!new_ah) {
 375                printk(KERN_WARNING "Couldn't allocate new SM AH\n");
 376                return;
 377        }
 378
 379        kref_init(&new_ah->ref);
 380        new_ah->src_path_mask = (1 << port_attr.lmc) - 1;
 381
 382        new_ah->pkey_index = 0;
 383        if (ib_find_pkey(port->agent->device, port->port_num,
 384                         IB_DEFAULT_PKEY_FULL, &new_ah->pkey_index))
 385                printk(KERN_ERR "Couldn't find index for default PKey\n");
 386
 387        memset(&ah_attr, 0, sizeof ah_attr);
 388        ah_attr.dlid     = port_attr.sm_lid;
 389        ah_attr.sl       = port_attr.sm_sl;
 390        ah_attr.port_num = port->port_num;
 391
 392        new_ah->ah = ib_create_ah(port->agent->qp->pd, &ah_attr);
 393        if (IS_ERR(new_ah->ah)) {
 394                printk(KERN_WARNING "Couldn't create new SM AH\n");
 395                kfree(new_ah);
 396                return;
 397        }
 398
 399        spin_lock_irq(&port->ah_lock);
 400        old_ah = port->sm_ah;
 401        port->sm_ah = new_ah;
 402        spin_unlock_irq(&port->ah_lock);
 403
 404        if (old_ah)
 405                kref_put(&old_ah->ref, free_sm_ah);
 406}
 407
 408static void ib_sa_event(struct ib_event_handler *handler, struct ib_event *event)
 409{
 410        if (event->event == IB_EVENT_PORT_ERR    ||
 411            event->event == IB_EVENT_PORT_ACTIVE ||
 412            event->event == IB_EVENT_LID_CHANGE  ||
 413            event->event == IB_EVENT_PKEY_CHANGE ||
 414            event->event == IB_EVENT_SM_CHANGE   ||
 415            event->event == IB_EVENT_CLIENT_REREGISTER) {
 416                struct ib_sa_device *sa_dev;
 417                sa_dev = container_of(handler, typeof(*sa_dev), event_handler);
 418
 419                schedule_work(&sa_dev->port[event->element.port_num -
 420                                            sa_dev->start_port].update_task);
 421        }
 422}
 423
 424void ib_sa_register_client(struct ib_sa_client *client)
 425{
 426        atomic_set(&client->users, 1);
 427        init_completion(&client->comp);
 428}
 429EXPORT_SYMBOL(ib_sa_register_client);
 430
 431void ib_sa_unregister_client(struct ib_sa_client *client)
 432{
 433        ib_sa_client_put(client);
 434        wait_for_completion(&client->comp);
 435}
 436EXPORT_SYMBOL(ib_sa_unregister_client);
 437
 438/**
 439 * ib_sa_cancel_query - try to cancel an SA query
 440 * @id:ID of query to cancel
 441 * @query:query pointer to cancel
 442 *
 443 * Try to cancel an SA query.  If the id and query don't match up or
 444 * the query has already completed, nothing is done.  Otherwise the
 445 * query is canceled and will complete with a status of -EINTR.
 446 */
 447void ib_sa_cancel_query(int id, struct ib_sa_query *query)
 448{
 449        unsigned long flags;
 450        struct ib_mad_agent *agent;
 451        struct ib_mad_send_buf *mad_buf;
 452
 453        spin_lock_irqsave(&idr_lock, flags);
 454        if (idr_find(&query_idr, id) != query) {
 455                spin_unlock_irqrestore(&idr_lock, flags);
 456                return;
 457        }
 458        agent = query->port->agent;
 459        mad_buf = query->mad_buf;
 460        spin_unlock_irqrestore(&idr_lock, flags);
 461
 462        ib_cancel_mad(agent, mad_buf);
 463}
 464EXPORT_SYMBOL(ib_sa_cancel_query);
 465
 466static u8 get_src_path_mask(struct ib_device *device, u8 port_num)
 467{
 468        struct ib_sa_device *sa_dev;
 469        struct ib_sa_port   *port;
 470        unsigned long flags;
 471        u8 src_path_mask;
 472
 473        sa_dev = ib_get_client_data(device, &sa_client);
 474        if (!sa_dev)
 475                return 0x7f;
 476
 477        port  = &sa_dev->port[port_num - sa_dev->start_port];
 478        spin_lock_irqsave(&port->ah_lock, flags);
 479        src_path_mask = port->sm_ah ? port->sm_ah->src_path_mask : 0x7f;
 480        spin_unlock_irqrestore(&port->ah_lock, flags);
 481
 482        return src_path_mask;
 483}
 484
 485int ib_init_ah_from_path(struct ib_device *device, u8 port_num,
 486                         struct ib_sa_path_rec *rec, struct ib_ah_attr *ah_attr)
 487{
 488        int ret;
 489        u16 gid_index;
 490
 491        memset(ah_attr, 0, sizeof *ah_attr);
 492        ah_attr->dlid = be16_to_cpu(rec->dlid);
 493        ah_attr->sl = rec->sl;
 494        ah_attr->src_path_bits = be16_to_cpu(rec->slid) &
 495                                 get_src_path_mask(device, port_num);
 496        ah_attr->port_num = port_num;
 497        ah_attr->static_rate = rec->rate;
 498
 499        if (rec->hop_limit > 1) {
 500                ah_attr->ah_flags = IB_AH_GRH;
 501                ah_attr->grh.dgid = rec->dgid;
 502
 503                ret = ib_find_cached_gid(device, &rec->sgid, &port_num,
 504                                         &gid_index);
 505                if (ret)
 506                        return ret;
 507
 508                ah_attr->grh.sgid_index    = gid_index;
 509                ah_attr->grh.flow_label    = be32_to_cpu(rec->flow_label);
 510                ah_attr->grh.hop_limit     = rec->hop_limit;
 511                ah_attr->grh.traffic_class = rec->traffic_class;
 512        }
 513        return 0;
 514}
 515EXPORT_SYMBOL(ib_init_ah_from_path);
 516
 517static int alloc_mad(struct ib_sa_query *query, gfp_t gfp_mask)
 518{
 519        unsigned long flags;
 520
 521        spin_lock_irqsave(&query->port->ah_lock, flags);
 522        kref_get(&query->port->sm_ah->ref);
 523        query->sm_ah = query->port->sm_ah;
 524        spin_unlock_irqrestore(&query->port->ah_lock, flags);
 525
 526        query->mad_buf = ib_create_send_mad(query->port->agent, 1,
 527                                            query->sm_ah->pkey_index,
 528                                            0, IB_MGMT_SA_HDR, IB_MGMT_SA_DATA,
 529                                            gfp_mask);
 530        if (IS_ERR(query->mad_buf)) {
 531                kref_put(&query->sm_ah->ref, free_sm_ah);
 532                return -ENOMEM;
 533        }
 534
 535        query->mad_buf->ah = query->sm_ah->ah;
 536
 537        return 0;
 538}
 539
 540static void free_mad(struct ib_sa_query *query)
 541{
 542        ib_free_send_mad(query->mad_buf);
 543        kref_put(&query->sm_ah->ref, free_sm_ah);
 544}
 545
 546static void init_mad(struct ib_sa_mad *mad, struct ib_mad_agent *agent)
 547{
 548        unsigned long flags;
 549
 550        memset(mad, 0, sizeof *mad);
 551
 552        mad->mad_hdr.base_version  = IB_MGMT_BASE_VERSION;
 553        mad->mad_hdr.mgmt_class    = IB_MGMT_CLASS_SUBN_ADM;
 554        mad->mad_hdr.class_version = IB_SA_CLASS_VERSION;
 555
 556        spin_lock_irqsave(&tid_lock, flags);
 557        mad->mad_hdr.tid           =
 558                cpu_to_be64(((u64) agent->hi_tid) << 32 | tid++);
 559        spin_unlock_irqrestore(&tid_lock, flags);
 560}
 561
 562static int send_mad(struct ib_sa_query *query, int timeout_ms, gfp_t gfp_mask)
 563{
 564        unsigned long flags;
 565        int ret, id;
 566
 567retry:
 568        if (!idr_pre_get(&query_idr, gfp_mask))
 569                return -ENOMEM;
 570        spin_lock_irqsave(&idr_lock, flags);
 571        ret = idr_get_new(&query_idr, query, &id);
 572        spin_unlock_irqrestore(&idr_lock, flags);
 573        if (ret == -EAGAIN)
 574                goto retry;
 575        if (ret)
 576                return ret;
 577
 578        query->mad_buf->timeout_ms  = timeout_ms;
 579        query->mad_buf->context[0] = query;
 580        query->id = id;
 581
 582        ret = ib_post_send_mad(query->mad_buf, NULL);
 583        if (ret) {
 584                spin_lock_irqsave(&idr_lock, flags);
 585                idr_remove(&query_idr, id);
 586                spin_unlock_irqrestore(&idr_lock, flags);
 587        }
 588
 589        /*
 590         * It's not safe to dereference query any more, because the
 591         * send may already have completed and freed the query in
 592         * another context.
 593         */
 594        return ret ? ret : id;
 595}
 596
 597static void ib_sa_path_rec_callback(struct ib_sa_query *sa_query,
 598                                    int status,
 599                                    struct ib_sa_mad *mad)
 600{
 601        struct ib_sa_path_query *query =
 602                container_of(sa_query, struct ib_sa_path_query, sa_query);
 603
 604        if (mad) {
 605                struct ib_sa_path_rec rec;
 606
 607                ib_unpack(path_rec_table, ARRAY_SIZE(path_rec_table),
 608                          mad->data, &rec);
 609                query->callback(status, &rec, query->context);
 610        } else
 611                query->callback(status, NULL, query->context);
 612}
 613
 614static void ib_sa_path_rec_release(struct ib_sa_query *sa_query)
 615{
 616        kfree(container_of(sa_query, struct ib_sa_path_query, sa_query));
 617}
 618
 619/**
 620 * ib_sa_path_rec_get - Start a Path get query
 621 * @client:SA client
 622 * @device:device to send query on
 623 * @port_num: port number to send query on
 624 * @rec:Path Record to send in query
 625 * @comp_mask:component mask to send in query
 626 * @timeout_ms:time to wait for response
 627 * @gfp_mask:GFP mask to use for internal allocations
 628 * @callback:function called when query completes, times out or is
 629 * canceled
 630 * @context:opaque user context passed to callback
 631 * @sa_query:query context, used to cancel query
 632 *
 633 * Send a Path Record Get query to the SA to look up a path.  The
 634 * callback function will be called when the query completes (or
 635 * fails); status is 0 for a successful response, -EINTR if the query
 636 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
 637 * occurred sending the query.  The resp parameter of the callback is
 638 * only valid if status is 0.
 639 *
 640 * If the return value of ib_sa_path_rec_get() is negative, it is an
 641 * error code.  Otherwise it is a query ID that can be used to cancel
 642 * the query.
 643 */
 644int ib_sa_path_rec_get(struct ib_sa_client *client,
 645                       struct ib_device *device, u8 port_num,
 646                       struct ib_sa_path_rec *rec,
 647                       ib_sa_comp_mask comp_mask,
 648                       int timeout_ms, gfp_t gfp_mask,
 649                       void (*callback)(int status,
 650                                        struct ib_sa_path_rec *resp,
 651                                        void *context),
 652                       void *context,
 653                       struct ib_sa_query **sa_query)
 654{
 655        struct ib_sa_path_query *query;
 656        struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
 657        struct ib_sa_port   *port;
 658        struct ib_mad_agent *agent;
 659        struct ib_sa_mad *mad;
 660        int ret;
 661
 662        if (!sa_dev)
 663                return -ENODEV;
 664
 665        port  = &sa_dev->port[port_num - sa_dev->start_port];
 666        agent = port->agent;
 667
 668        query = kmalloc(sizeof *query, gfp_mask);
 669        if (!query)
 670                return -ENOMEM;
 671
 672        query->sa_query.port     = port;
 673        ret = alloc_mad(&query->sa_query, gfp_mask);
 674        if (ret)
 675                goto err1;
 676
 677        ib_sa_client_get(client);
 678        query->sa_query.client = client;
 679        query->callback        = callback;
 680        query->context         = context;
 681
 682        mad = query->sa_query.mad_buf->mad;
 683        init_mad(mad, agent);
 684
 685        query->sa_query.callback = callback ? ib_sa_path_rec_callback : NULL;
 686        query->sa_query.release  = ib_sa_path_rec_release;
 687        mad->mad_hdr.method      = IB_MGMT_METHOD_GET;
 688        mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_PATH_REC);
 689        mad->sa_hdr.comp_mask    = comp_mask;
 690
 691        ib_pack(path_rec_table, ARRAY_SIZE(path_rec_table), rec, mad->data);
 692
 693        *sa_query = &query->sa_query;
 694
 695        ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
 696        if (ret < 0)
 697                goto err2;
 698
 699        return ret;
 700
 701err2:
 702        *sa_query = NULL;
 703        ib_sa_client_put(query->sa_query.client);
 704        free_mad(&query->sa_query);
 705
 706err1:
 707        kfree(query);
 708        return ret;
 709}
 710EXPORT_SYMBOL(ib_sa_path_rec_get);
 711
 712static void ib_sa_service_rec_callback(struct ib_sa_query *sa_query,
 713                                    int status,
 714                                    struct ib_sa_mad *mad)
 715{
 716        struct ib_sa_service_query *query =
 717                container_of(sa_query, struct ib_sa_service_query, sa_query);
 718
 719        if (mad) {
 720                struct ib_sa_service_rec rec;
 721
 722                ib_unpack(service_rec_table, ARRAY_SIZE(service_rec_table),
 723                          mad->data, &rec);
 724                query->callback(status, &rec, query->context);
 725        } else
 726                query->callback(status, NULL, query->context);
 727}
 728
 729static void ib_sa_service_rec_release(struct ib_sa_query *sa_query)
 730{
 731        kfree(container_of(sa_query, struct ib_sa_service_query, sa_query));
 732}
 733
 734/**
 735 * ib_sa_service_rec_query - Start Service Record operation
 736 * @client:SA client
 737 * @device:device to send request on
 738 * @port_num: port number to send request on
 739 * @method:SA method - should be get, set, or delete
 740 * @rec:Service Record to send in request
 741 * @comp_mask:component mask to send in request
 742 * @timeout_ms:time to wait for response
 743 * @gfp_mask:GFP mask to use for internal allocations
 744 * @callback:function called when request completes, times out or is
 745 * canceled
 746 * @context:opaque user context passed to callback
 747 * @sa_query:request context, used to cancel request
 748 *
 749 * Send a Service Record set/get/delete to the SA to register,
 750 * unregister or query a service record.
 751 * The callback function will be called when the request completes (or
 752 * fails); status is 0 for a successful response, -EINTR if the query
 753 * is canceled, -ETIMEDOUT is the query timed out, or -EIO if an error
 754 * occurred sending the query.  The resp parameter of the callback is
 755 * only valid if status is 0.
 756 *
 757 * If the return value of ib_sa_service_rec_query() is negative, it is an
 758 * error code.  Otherwise it is a request ID that can be used to cancel
 759 * the query.
 760 */
 761int ib_sa_service_rec_query(struct ib_sa_client *client,
 762                            struct ib_device *device, u8 port_num, u8 method,
 763                            struct ib_sa_service_rec *rec,
 764                            ib_sa_comp_mask comp_mask,
 765                            int timeout_ms, gfp_t gfp_mask,
 766                            void (*callback)(int status,
 767                                             struct ib_sa_service_rec *resp,
 768                                             void *context),
 769                            void *context,
 770                            struct ib_sa_query **sa_query)
 771{
 772        struct ib_sa_service_query *query;
 773        struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
 774        struct ib_sa_port   *port;
 775        struct ib_mad_agent *agent;
 776        struct ib_sa_mad *mad;
 777        int ret;
 778
 779        if (!sa_dev)
 780                return -ENODEV;
 781
 782        port  = &sa_dev->port[port_num - sa_dev->start_port];
 783        agent = port->agent;
 784
 785        if (method != IB_MGMT_METHOD_GET &&
 786            method != IB_MGMT_METHOD_SET &&
 787            method != IB_SA_METHOD_DELETE)
 788                return -EINVAL;
 789
 790        query = kmalloc(sizeof *query, gfp_mask);
 791        if (!query)
 792                return -ENOMEM;
 793
 794        query->sa_query.port     = port;
 795        ret = alloc_mad(&query->sa_query, gfp_mask);
 796        if (ret)
 797                goto err1;
 798
 799        ib_sa_client_get(client);
 800        query->sa_query.client = client;
 801        query->callback        = callback;
 802        query->context         = context;
 803
 804        mad = query->sa_query.mad_buf->mad;
 805        init_mad(mad, agent);
 806
 807        query->sa_query.callback = callback ? ib_sa_service_rec_callback : NULL;
 808        query->sa_query.release  = ib_sa_service_rec_release;
 809        mad->mad_hdr.method      = method;
 810        mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_SERVICE_REC);
 811        mad->sa_hdr.comp_mask    = comp_mask;
 812
 813        ib_pack(service_rec_table, ARRAY_SIZE(service_rec_table),
 814                rec, mad->data);
 815
 816        *sa_query = &query->sa_query;
 817
 818        ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
 819        if (ret < 0)
 820                goto err2;
 821
 822        return ret;
 823
 824err2:
 825        *sa_query = NULL;
 826        ib_sa_client_put(query->sa_query.client);
 827        free_mad(&query->sa_query);
 828
 829err1:
 830        kfree(query);
 831        return ret;
 832}
 833EXPORT_SYMBOL(ib_sa_service_rec_query);
 834
 835static void ib_sa_mcmember_rec_callback(struct ib_sa_query *sa_query,
 836                                        int status,
 837                                        struct ib_sa_mad *mad)
 838{
 839        struct ib_sa_mcmember_query *query =
 840                container_of(sa_query, struct ib_sa_mcmember_query, sa_query);
 841
 842        if (mad) {
 843                struct ib_sa_mcmember_rec rec;
 844
 845                ib_unpack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
 846                          mad->data, &rec);
 847                query->callback(status, &rec, query->context);
 848        } else
 849                query->callback(status, NULL, query->context);
 850}
 851
 852static void ib_sa_mcmember_rec_release(struct ib_sa_query *sa_query)
 853{
 854        kfree(container_of(sa_query, struct ib_sa_mcmember_query, sa_query));
 855}
 856
 857int ib_sa_mcmember_rec_query(struct ib_sa_client *client,
 858                             struct ib_device *device, u8 port_num,
 859                             u8 method,
 860                             struct ib_sa_mcmember_rec *rec,
 861                             ib_sa_comp_mask comp_mask,
 862                             int timeout_ms, gfp_t gfp_mask,
 863                             void (*callback)(int status,
 864                                              struct ib_sa_mcmember_rec *resp,
 865                                              void *context),
 866                             void *context,
 867                             struct ib_sa_query **sa_query)
 868{
 869        struct ib_sa_mcmember_query *query;
 870        struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
 871        struct ib_sa_port   *port;
 872        struct ib_mad_agent *agent;
 873        struct ib_sa_mad *mad;
 874        int ret;
 875
 876        if (!sa_dev)
 877                return -ENODEV;
 878
 879        port  = &sa_dev->port[port_num - sa_dev->start_port];
 880        agent = port->agent;
 881
 882        query = kmalloc(sizeof *query, gfp_mask);
 883        if (!query)
 884                return -ENOMEM;
 885
 886        query->sa_query.port     = port;
 887        ret = alloc_mad(&query->sa_query, gfp_mask);
 888        if (ret)
 889                goto err1;
 890
 891        ib_sa_client_get(client);
 892        query->sa_query.client = client;
 893        query->callback        = callback;
 894        query->context         = context;
 895
 896        mad = query->sa_query.mad_buf->mad;
 897        init_mad(mad, agent);
 898
 899        query->sa_query.callback = callback ? ib_sa_mcmember_rec_callback : NULL;
 900        query->sa_query.release  = ib_sa_mcmember_rec_release;
 901        mad->mad_hdr.method      = method;
 902        mad->mad_hdr.attr_id     = cpu_to_be16(IB_SA_ATTR_MC_MEMBER_REC);
 903        mad->sa_hdr.comp_mask    = comp_mask;
 904
 905        ib_pack(mcmember_rec_table, ARRAY_SIZE(mcmember_rec_table),
 906                rec, mad->data);
 907
 908        *sa_query = &query->sa_query;
 909
 910        ret = send_mad(&query->sa_query, timeout_ms, gfp_mask);
 911        if (ret < 0)
 912                goto err2;
 913
 914        return ret;
 915
 916err2:
 917        *sa_query = NULL;
 918        ib_sa_client_put(query->sa_query.client);
 919        free_mad(&query->sa_query);
 920
 921err1:
 922        kfree(query);
 923        return ret;
 924}
 925
 926static void send_handler(struct ib_mad_agent *agent,
 927                         struct ib_mad_send_wc *mad_send_wc)
 928{
 929        struct ib_sa_query *query = mad_send_wc->send_buf->context[0];
 930        unsigned long flags;
 931
 932        if (query->callback)
 933                switch (mad_send_wc->status) {
 934                case IB_WC_SUCCESS:
 935                        /* No callback -- already got recv */
 936                        break;
 937                case IB_WC_RESP_TIMEOUT_ERR:
 938                        query->callback(query, -ETIMEDOUT, NULL);
 939                        break;
 940                case IB_WC_WR_FLUSH_ERR:
 941                        query->callback(query, -EINTR, NULL);
 942                        break;
 943                default:
 944                        query->callback(query, -EIO, NULL);
 945                        break;
 946                }
 947
 948        spin_lock_irqsave(&idr_lock, flags);
 949        idr_remove(&query_idr, query->id);
 950        spin_unlock_irqrestore(&idr_lock, flags);
 951
 952        free_mad(query);
 953        ib_sa_client_put(query->client);
 954        query->release(query);
 955}
 956
 957static void recv_handler(struct ib_mad_agent *mad_agent,
 958                         struct ib_mad_recv_wc *mad_recv_wc)
 959{
 960        struct ib_sa_query *query;
 961        struct ib_mad_send_buf *mad_buf;
 962
 963        mad_buf = (void *) (unsigned long) mad_recv_wc->wc->wr_id;
 964        query = mad_buf->context[0];
 965
 966        if (query->callback) {
 967                if (mad_recv_wc->wc->status == IB_WC_SUCCESS)
 968                        query->callback(query,
 969                                        mad_recv_wc->recv_buf.mad->mad_hdr.status ?
 970                                        -EINVAL : 0,
 971                                        (struct ib_sa_mad *) mad_recv_wc->recv_buf.mad);
 972                else
 973                        query->callback(query, -EIO, NULL);
 974        }
 975
 976        ib_free_recv_mad(mad_recv_wc);
 977}
 978
 979static void ib_sa_add_one(struct ib_device *device)
 980{
 981        struct ib_sa_device *sa_dev;
 982        int s, e, i;
 983
 984        if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
 985                return;
 986
 987        if (device->node_type == RDMA_NODE_IB_SWITCH)
 988                s = e = 0;
 989        else {
 990                s = 1;
 991                e = device->phys_port_cnt;
 992        }
 993
 994        sa_dev = kmalloc(sizeof *sa_dev +
 995                         (e - s + 1) * sizeof (struct ib_sa_port),
 996                         GFP_KERNEL);
 997        if (!sa_dev)
 998                return;
 999
1000        sa_dev->start_port = s;
1001        sa_dev->end_port   = e;
1002
1003        for (i = 0; i <= e - s; ++i) {
1004                sa_dev->port[i].sm_ah    = NULL;
1005                sa_dev->port[i].port_num = i + s;
1006                spin_lock_init(&sa_dev->port[i].ah_lock);
1007
1008                sa_dev->port[i].agent =
1009                        ib_register_mad_agent(device, i + s, IB_QPT_GSI,
1010                                              NULL, 0, send_handler,
1011                                              recv_handler, sa_dev);
1012                if (IS_ERR(sa_dev->port[i].agent))
1013                        goto err;
1014
1015                INIT_WORK(&sa_dev->port[i].update_task, update_sm_ah);
1016        }
1017
1018        ib_set_client_data(device, &sa_client, sa_dev);
1019
1020        /*
1021         * We register our event handler after everything is set up,
1022         * and then update our cached info after the event handler is
1023         * registered to avoid any problems if a port changes state
1024         * during our initialization.
1025         */
1026
1027        INIT_IB_EVENT_HANDLER(&sa_dev->event_handler, device, ib_sa_event);
1028        if (ib_register_event_handler(&sa_dev->event_handler))
1029                goto err;
1030
1031        for (i = 0; i <= e - s; ++i)
1032                update_sm_ah(&sa_dev->port[i].update_task);
1033
1034        return;
1035
1036err:
1037        while (--i >= 0)
1038                ib_unregister_mad_agent(sa_dev->port[i].agent);
1039
1040        kfree(sa_dev);
1041
1042        return;
1043}
1044
1045static void ib_sa_remove_one(struct ib_device *device)
1046{
1047        struct ib_sa_device *sa_dev = ib_get_client_data(device, &sa_client);
1048        int i;
1049
1050        if (!sa_dev)
1051                return;
1052
1053        ib_unregister_event_handler(&sa_dev->event_handler);
1054
1055        flush_scheduled_work();
1056
1057        for (i = 0; i <= sa_dev->end_port - sa_dev->start_port; ++i) {
1058                ib_unregister_mad_agent(sa_dev->port[i].agent);
1059                kref_put(&sa_dev->port[i].sm_ah->ref, free_sm_ah);
1060        }
1061
1062        kfree(sa_dev);
1063}
1064
1065static int __init ib_sa_init(void)
1066{
1067        int ret;
1068
1069        spin_lock_init(&idr_lock);
1070        spin_lock_init(&tid_lock);
1071
1072        get_random_bytes(&tid, sizeof tid);
1073
1074        ret = ib_register_client(&sa_client);
1075        if (ret) {
1076                printk(KERN_ERR "Couldn't register ib_sa client\n");
1077                goto err1;
1078        }
1079
1080        ret = mcast_init();
1081        if (ret) {
1082                printk(KERN_ERR "Couldn't initialize multicast handling\n");
1083                goto err2;
1084        }
1085
1086        return 0;
1087err2:
1088        ib_unregister_client(&sa_client);
1089err1:
1090        return ret;
1091}
1092
1093static void __exit ib_sa_cleanup(void)
1094{
1095        mcast_cleanup();
1096        ib_unregister_client(&sa_client);
1097        idr_destroy(&query_idr);
1098}
1099
1100module_init(ib_sa_init);
1101module_exit(ib_sa_cleanup);
1102
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.