linux/include/rdma/ib_cm.h
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2004, 2005 Intel Corporation.  All rights reserved.
   3 * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
   4 * Copyright (c) 2004 Voltaire Corporation.  All rights reserved.
   5 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
   6 *
   7 * This software is available to you under a choice of one of two
   8 * licenses.  You may choose to be licensed under the terms of the GNU
   9 * General Public License (GPL) Version 2, available from the file
  10 * COPYING in the main directory of this source tree, or the
  11 * OpenIB.org BSD license below:
  12 *
  13 *     Redistribution and use in source and binary forms, with or
  14 *     without modification, are permitted provided that the following
  15 *     conditions are met:
  16 *
  17 *      - Redistributions of source code must retain the above
  18 *        copyright notice, this list of conditions and the following
  19 *        disclaimer.
  20 *
  21 *      - Redistributions in binary form must reproduce the above
  22 *        copyright notice, this list of conditions and the following
  23 *        disclaimer in the documentation and/or other materials
  24 *        provided with the distribution.
  25 *
  26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33 * SOFTWARE.
  34 */
  35#if !defined(IB_CM_H)
  36#define IB_CM_H
  37
  38#include <rdma/ib_mad.h>
  39#include <rdma/ib_sa.h>
  40
  41enum ib_cm_state {
  42        IB_CM_IDLE,
  43        IB_CM_LISTEN,
  44        IB_CM_REQ_SENT,
  45        IB_CM_REQ_RCVD,
  46        IB_CM_MRA_REQ_SENT,
  47        IB_CM_MRA_REQ_RCVD,
  48        IB_CM_REP_SENT,
  49        IB_CM_REP_RCVD,
  50        IB_CM_MRA_REP_SENT,
  51        IB_CM_MRA_REP_RCVD,
  52        IB_CM_ESTABLISHED,
  53        IB_CM_DREQ_SENT,
  54        IB_CM_DREQ_RCVD,
  55        IB_CM_TIMEWAIT,
  56        IB_CM_SIDR_REQ_SENT,
  57        IB_CM_SIDR_REQ_RCVD
  58};
  59
  60enum ib_cm_lap_state {
  61        IB_CM_LAP_UNINIT,
  62        IB_CM_LAP_IDLE,
  63        IB_CM_LAP_SENT,
  64        IB_CM_LAP_RCVD,
  65        IB_CM_MRA_LAP_SENT,
  66        IB_CM_MRA_LAP_RCVD,
  67};
  68
  69enum ib_cm_event_type {
  70        IB_CM_REQ_ERROR,
  71        IB_CM_REQ_RECEIVED,
  72        IB_CM_REP_ERROR,
  73        IB_CM_REP_RECEIVED,
  74        IB_CM_RTU_RECEIVED,
  75        IB_CM_USER_ESTABLISHED,
  76        IB_CM_DREQ_ERROR,
  77        IB_CM_DREQ_RECEIVED,
  78        IB_CM_DREP_RECEIVED,
  79        IB_CM_TIMEWAIT_EXIT,
  80        IB_CM_MRA_RECEIVED,
  81        IB_CM_REJ_RECEIVED,
  82        IB_CM_LAP_ERROR,
  83        IB_CM_LAP_RECEIVED,
  84        IB_CM_APR_RECEIVED,
  85        IB_CM_SIDR_REQ_ERROR,
  86        IB_CM_SIDR_REQ_RECEIVED,
  87        IB_CM_SIDR_REP_RECEIVED
  88};
  89
  90enum ib_cm_data_size {
  91        IB_CM_REQ_PRIVATE_DATA_SIZE      = 92,
  92        IB_CM_MRA_PRIVATE_DATA_SIZE      = 222,
  93        IB_CM_REJ_PRIVATE_DATA_SIZE      = 148,
  94        IB_CM_REP_PRIVATE_DATA_SIZE      = 196,
  95        IB_CM_RTU_PRIVATE_DATA_SIZE      = 224,
  96        IB_CM_DREQ_PRIVATE_DATA_SIZE     = 220,
  97        IB_CM_DREP_PRIVATE_DATA_SIZE     = 224,
  98        IB_CM_REJ_ARI_LENGTH             = 72,
  99        IB_CM_LAP_PRIVATE_DATA_SIZE      = 168,
 100        IB_CM_APR_PRIVATE_DATA_SIZE      = 148,
 101        IB_CM_APR_INFO_LENGTH            = 72,
 102        IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE = 216,
 103        IB_CM_SIDR_REP_PRIVATE_DATA_SIZE = 136,
 104        IB_CM_SIDR_REP_INFO_LENGTH       = 72,
 105        IB_CM_COMPARE_SIZE               = 64
 106};
 107
 108struct ib_cm_id;
 109
 110struct ib_cm_req_event_param {
 111        struct ib_cm_id         *listen_id;
 112        u8                      port;
 113
 114        struct ib_sa_path_rec   *primary_path;
 115        struct ib_sa_path_rec   *alternate_path;
 116
 117        __be64                  remote_ca_guid;
 118        u32                     remote_qkey;
 119        u32                     remote_qpn;
 120        enum ib_qp_type         qp_type;
 121
 122        u32                     starting_psn;
 123        u8                      responder_resources;
 124        u8                      initiator_depth;
 125        unsigned int            local_cm_response_timeout:5;
 126        unsigned int            flow_control:1;
 127        unsigned int            remote_cm_response_timeout:5;
 128        unsigned int            retry_count:3;
 129        unsigned int            rnr_retry_count:3;
 130        unsigned int            srq:1;
 131};
 132
 133struct ib_cm_rep_event_param {
 134        __be64                  remote_ca_guid;
 135        u32                     remote_qkey;
 136        u32                     remote_qpn;
 137        u32                     starting_psn;
 138        u8                      responder_resources;
 139        u8                      initiator_depth;
 140        unsigned int            target_ack_delay:5;
 141        unsigned int            failover_accepted:2;
 142        unsigned int            flow_control:1;
 143        unsigned int            rnr_retry_count:3;
 144        unsigned int            srq:1;
 145};
 146
 147enum ib_cm_rej_reason {
 148        IB_CM_REJ_NO_QP                         = 1,
 149        IB_CM_REJ_NO_EEC                        = 2,
 150        IB_CM_REJ_NO_RESOURCES                  = 3,
 151        IB_CM_REJ_TIMEOUT                       = 4,
 152        IB_CM_REJ_UNSUPPORTED                   = 5,
 153        IB_CM_REJ_INVALID_COMM_ID               = 6,
 154        IB_CM_REJ_INVALID_COMM_INSTANCE         = 7,
 155        IB_CM_REJ_INVALID_SERVICE_ID            = 8,
 156        IB_CM_REJ_INVALID_TRANSPORT_TYPE        = 9,
 157        IB_CM_REJ_STALE_CONN                    = 10,
 158        IB_CM_REJ_RDC_NOT_EXIST                 = 11,
 159        IB_CM_REJ_INVALID_GID                   = 12,
 160        IB_CM_REJ_INVALID_LID                   = 13,
 161        IB_CM_REJ_INVALID_SL                    = 14,
 162        IB_CM_REJ_INVALID_TRAFFIC_CLASS         = 15,
 163        IB_CM_REJ_INVALID_HOP_LIMIT             = 16,
 164        IB_CM_REJ_INVALID_PACKET_RATE           = 17,
 165        IB_CM_REJ_INVALID_ALT_GID               = 18,
 166        IB_CM_REJ_INVALID_ALT_LID               = 19,
 167        IB_CM_REJ_INVALID_ALT_SL                = 20,
 168        IB_CM_REJ_INVALID_ALT_TRAFFIC_CLASS     = 21,
 169        IB_CM_REJ_INVALID_ALT_HOP_LIMIT         = 22,
 170        IB_CM_REJ_INVALID_ALT_PACKET_RATE       = 23,
 171        IB_CM_REJ_PORT_CM_REDIRECT              = 24,
 172        IB_CM_REJ_PORT_REDIRECT                 = 25,
 173        IB_CM_REJ_INVALID_MTU                   = 26,
 174        IB_CM_REJ_INSUFFICIENT_RESP_RESOURCES   = 27,
 175        IB_CM_REJ_CONSUMER_DEFINED              = 28,
 176        IB_CM_REJ_INVALID_RNR_RETRY             = 29,
 177        IB_CM_REJ_DUPLICATE_LOCAL_COMM_ID       = 30,
 178        IB_CM_REJ_INVALID_CLASS_VERSION         = 31,
 179        IB_CM_REJ_INVALID_FLOW_LABEL            = 32,
 180        IB_CM_REJ_INVALID_ALT_FLOW_LABEL        = 33
 181};
 182
 183struct ib_cm_rej_event_param {
 184        enum ib_cm_rej_reason   reason;
 185        void                    *ari;
 186        u8                      ari_length;
 187};
 188
 189struct ib_cm_mra_event_param {
 190        u8      service_timeout;
 191};
 192
 193struct ib_cm_lap_event_param {
 194        struct ib_sa_path_rec   *alternate_path;
 195};
 196
 197enum ib_cm_apr_status {
 198        IB_CM_APR_SUCCESS,
 199        IB_CM_APR_INVALID_COMM_ID,
 200        IB_CM_APR_UNSUPPORTED,
 201        IB_CM_APR_REJECT,
 202        IB_CM_APR_REDIRECT,
 203        IB_CM_APR_IS_CURRENT,
 204        IB_CM_APR_INVALID_QPN_EECN,
 205        IB_CM_APR_INVALID_LID,
 206        IB_CM_APR_INVALID_GID,
 207        IB_CM_APR_INVALID_FLOW_LABEL,
 208        IB_CM_APR_INVALID_TCLASS,
 209        IB_CM_APR_INVALID_HOP_LIMIT,
 210        IB_CM_APR_INVALID_PACKET_RATE,
 211        IB_CM_APR_INVALID_SL
 212};
 213
 214struct ib_cm_apr_event_param {
 215        enum ib_cm_apr_status   ap_status;
 216        void                    *apr_info;
 217        u8                      info_len;
 218};
 219
 220struct ib_cm_sidr_req_event_param {
 221        struct ib_cm_id         *listen_id;
 222        u8                      port;
 223        u16                     pkey;
 224};
 225
 226enum ib_cm_sidr_status {
 227        IB_SIDR_SUCCESS,
 228        IB_SIDR_UNSUPPORTED,
 229        IB_SIDR_REJECT,
 230        IB_SIDR_NO_QP,
 231        IB_SIDR_REDIRECT,
 232        IB_SIDR_UNSUPPORTED_VERSION
 233};
 234
 235struct ib_cm_sidr_rep_event_param {
 236        enum ib_cm_sidr_status  status;
 237        u32                     qkey;
 238        u32                     qpn;
 239        void                    *info;
 240        u8                      info_len;
 241};
 242
 243struct ib_cm_event {
 244        enum ib_cm_event_type   event;
 245        union {
 246                struct ib_cm_req_event_param    req_rcvd;
 247                struct ib_cm_rep_event_param    rep_rcvd;
 248                /* No data for RTU received events. */
 249                struct ib_cm_rej_event_param    rej_rcvd;
 250                struct ib_cm_mra_event_param    mra_rcvd;
 251                struct ib_cm_lap_event_param    lap_rcvd;
 252                struct ib_cm_apr_event_param    apr_rcvd;
 253                /* No data for DREQ/DREP received events. */
 254                struct ib_cm_sidr_req_event_param sidr_req_rcvd;
 255                struct ib_cm_sidr_rep_event_param sidr_rep_rcvd;
 256                enum ib_wc_status               send_status;
 257        } param;
 258
 259        void                    *private_data;
 260};
 261
 262/**
 263 * ib_cm_handler - User-defined callback to process communication events.
 264 * @cm_id: Communication identifier associated with the reported event.
 265 * @event: Information about the communication event.
 266 *
 267 * IB_CM_REQ_RECEIVED and IB_CM_SIDR_REQ_RECEIVED communication events
 268 * generated as a result of listen requests result in the allocation of a
 269 * new @cm_id.  The new @cm_id is returned to the user through this callback.
 270 * Clients are responsible for destroying the new @cm_id.  For peer-to-peer
 271 * IB_CM_REQ_RECEIVED and all other events, the returned @cm_id corresponds
 272 * to a user's existing communication identifier.
 273 *
 274 * Users may not call ib_destroy_cm_id while in the context of this callback;
 275 * however, returning a non-zero value instructs the communication manager to
 276 * destroy the @cm_id after the callback completes.
 277 */
 278typedef int (*ib_cm_handler)(struct ib_cm_id *cm_id,
 279                             struct ib_cm_event *event);
 280
 281struct ib_cm_id {
 282        ib_cm_handler           cm_handler;
 283        void                    *context;
 284        struct ib_device        *device;
 285        __be64                  service_id;
 286        __be64                  service_mask;
 287        enum ib_cm_state        state;          /* internal CM/debug use */
 288        enum ib_cm_lap_state    lap_state;      /* internal CM/debug use */
 289        __be32                  local_id;
 290        __be32                  remote_id;
 291        u32                     remote_cm_qpn;  /* 1 unless redirected */
 292};
 293
 294/**
 295 * ib_create_cm_id - Allocate a communication identifier.
 296 * @device: Device associated with the cm_id.  All related communication will
 297 * be associated with the specified device.
 298 * @cm_handler: Callback invoked to notify the user of CM events.
 299 * @context: User specified context associated with the communication
 300 *   identifier.
 301 *
 302 * Communication identifiers are used to track connection states, service
 303 * ID resolution requests, and listen requests.
 304 */
 305struct ib_cm_id *ib_create_cm_id(struct ib_device *device,
 306                                 ib_cm_handler cm_handler,
 307                                 void *context);
 308
 309/**
 310 * ib_destroy_cm_id - Destroy a connection identifier.
 311 * @cm_id: Connection identifier to destroy.
 312 *
 313 * This call blocks until the connection identifier is destroyed.
 314 */
 315void ib_destroy_cm_id(struct ib_cm_id *cm_id);
 316
 317#define IB_SERVICE_ID_AGN_MASK  __constant_cpu_to_be64(0xFF00000000000000ULL)
 318#define IB_CM_ASSIGN_SERVICE_ID __constant_cpu_to_be64(0x0200000000000000ULL)
 319#define IB_CMA_SERVICE_ID       __constant_cpu_to_be64(0x0000000001000000ULL)
 320#define IB_CMA_SERVICE_ID_MASK  __constant_cpu_to_be64(0xFFFFFFFFFF000000ULL)
 321#define IB_SDP_SERVICE_ID       __constant_cpu_to_be64(0x0000000000010000ULL)
 322#define IB_SDP_SERVICE_ID_MASK  __constant_cpu_to_be64(0xFFFFFFFFFFFF0000ULL)
 323
 324struct ib_cm_compare_data {
 325        u8  data[IB_CM_COMPARE_SIZE];
 326        u8  mask[IB_CM_COMPARE_SIZE];
 327};
 328
 329/**
 330 * ib_cm_listen - Initiates listening on the specified service ID for
 331 *   connection and service ID resolution requests.
 332 * @cm_id: Connection identifier associated with the listen request.
 333 * @service_id: Service identifier matched against incoming connection
 334 *   and service ID resolution requests.  The service ID should be specified
 335 *   network-byte order.  If set to IB_CM_ASSIGN_SERVICE_ID, the CM will
 336 *   assign a service ID to the caller.
 337 * @service_mask: Mask applied to service ID used to listen across a
 338 *   range of service IDs.  If set to 0, the service ID is matched
 339 *   exactly.  This parameter is ignored if %service_id is set to
 340 *   IB_CM_ASSIGN_SERVICE_ID.
 341 * @compare_data: This parameter is optional.  It specifies data that must
 342 *   appear in the private data of a connection request for the specified
 343 *   listen request.
 344 */
 345int ib_cm_listen(struct ib_cm_id *cm_id, __be64 service_id, __be64 service_mask,
 346                 struct ib_cm_compare_data *compare_data);
 347
 348struct ib_cm_req_param {
 349        struct ib_sa_path_rec   *primary_path;
 350        struct ib_sa_path_rec   *alternate_path;
 351        __be64                  service_id;
 352        u32                     qp_num;
 353        enum ib_qp_type         qp_type;
 354        u32                     starting_psn;
 355        const void              *private_data;
 356        u8                      private_data_len;
 357        u8                      peer_to_peer;
 358        u8                      responder_resources;
 359        u8                      initiator_depth;
 360        u8                      remote_cm_response_timeout;
 361        u8                      flow_control;
 362        u8                      local_cm_response_timeout;
 363        u8                      retry_count;
 364        u8                      rnr_retry_count;
 365        u8                      max_cm_retries;
 366        u8                      srq;
 367};
 368
 369/**
 370 * ib_send_cm_req - Sends a connection request to the remote node.
 371 * @cm_id: Connection identifier that will be associated with the
 372 *   connection request.
 373 * @param: Connection request information needed to establish the
 374 *   connection.
 375 */
 376int ib_send_cm_req(struct ib_cm_id *cm_id,
 377                   struct ib_cm_req_param *param);
 378
 379struct ib_cm_rep_param {
 380        u32             qp_num;
 381        u32             starting_psn;
 382        const void      *private_data;
 383        u8              private_data_len;
 384        u8              responder_resources;
 385        u8              initiator_depth;
 386        u8              failover_accepted;
 387        u8              flow_control;
 388        u8              rnr_retry_count;
 389        u8              srq;
 390};
 391
 392/**
 393 * ib_send_cm_rep - Sends a connection reply in response to a connection
 394 *   request.
 395 * @cm_id: Connection identifier that will be associated with the
 396 *   connection request.
 397 * @param: Connection reply information needed to establish the
 398 *   connection.
 399 */
 400int ib_send_cm_rep(struct ib_cm_id *cm_id,
 401                   struct ib_cm_rep_param *param);
 402
 403/**
 404 * ib_send_cm_rtu - Sends a connection ready to use message in response
 405 *   to a connection reply message.
 406 * @cm_id: Connection identifier associated with the connection request.
 407 * @private_data: Optional user-defined private data sent with the
 408 *   ready to use message.
 409 * @private_data_len: Size of the private data buffer, in bytes.
 410 */
 411int ib_send_cm_rtu(struct ib_cm_id *cm_id,
 412                   const void *private_data,
 413                   u8 private_data_len);
 414
 415/**
 416 * ib_send_cm_dreq - Sends a disconnection request for an existing
 417 *   connection.
 418 * @cm_id: Connection identifier associated with the connection being
 419 *   released.
 420 * @private_data: Optional user-defined private data sent with the
 421 *   disconnection request message.
 422 * @private_data_len: Size of the private data buffer, in bytes.
 423 */
 424int ib_send_cm_dreq(struct ib_cm_id *cm_id,
 425                    const void *private_data,
 426                    u8 private_data_len);
 427
 428/**
 429 * ib_send_cm_drep - Sends a disconnection reply to a disconnection request.
 430 * @cm_id: Connection identifier associated with the connection being
 431 *   released.
 432 * @private_data: Optional user-defined private data sent with the
 433 *   disconnection reply message.
 434 * @private_data_len: Size of the private data buffer, in bytes.
 435 *
 436 * If the cm_id is in the correct state, the CM will transition the connection
 437 * to the timewait state, even if an error occurs sending the DREP message.
 438 */
 439int ib_send_cm_drep(struct ib_cm_id *cm_id,
 440                    const void *private_data,
 441                    u8 private_data_len);
 442
 443/**
 444 * ib_cm_notify - Notifies the CM of an event reported to the consumer.
 445 * @cm_id: Connection identifier to transition to established.
 446 * @event: Type of event.
 447 *
 448 * This routine should be invoked by users to notify the CM of relevant
 449 * communication events.  Events that should be reported to the CM and
 450 * when to report them are:
 451 *
 452 * IB_EVENT_COMM_EST - Used when a message is received on a connected
 453 *    QP before an RTU has been received.
 454 * IB_EVENT_PATH_MIG - Notifies the CM that the connection has failed over
 455 *   to the alternate path.
 456 */
 457int ib_cm_notify(struct ib_cm_id *cm_id, enum ib_event_type event);
 458
 459/**
 460 * ib_send_cm_rej - Sends a connection rejection message to the
 461 *   remote node.
 462 * @cm_id: Connection identifier associated with the connection being
 463 *   rejected.
 464 * @reason: Reason for the connection request rejection.
 465 * @ari: Optional additional rejection information.
 466 * @ari_length: Size of the additional rejection information, in bytes.
 467 * @private_data: Optional user-defined private data sent with the
 468 *   rejection message.
 469 * @private_data_len: Size of the private data buffer, in bytes.
 470 */
 471int ib_send_cm_rej(struct ib_cm_id *cm_id,
 472                   enum ib_cm_rej_reason reason,
 473                   void *ari,
 474                   u8 ari_length,
 475                   const void *private_data,
 476                   u8 private_data_len);
 477
 478#define IB_CM_MRA_FLAG_DELAY 0x80  /* Send MRA only after a duplicate msg */
 479
 480/**
 481 * ib_send_cm_mra - Sends a message receipt acknowledgement to a connection
 482 *   message.
 483 * @cm_id: Connection identifier associated with the connection message.
 484 * @service_timeout: The lower 5-bits specify the maximum time required for
 485 *   the sender to reply to to the connection message.  The upper 3-bits
 486 *   specify additional control flags.
 487 * @private_data: Optional user-defined private data sent with the
 488 *   message receipt acknowledgement.
 489 * @private_data_len: Size of the private data buffer, in bytes.
 490 */
 491int ib_send_cm_mra(struct ib_cm_id *cm_id,
 492                   u8 service_timeout,
 493                   const void *private_data,
 494                   u8 private_data_len);
 495
 496/**
 497 * ib_send_cm_lap - Sends a load alternate path request.
 498 * @cm_id: Connection identifier associated with the load alternate path
 499 *   message.
 500 * @alternate_path: A path record that identifies the alternate path to
 501 *   load.
 502 * @private_data: Optional user-defined private data sent with the
 503 *   load alternate path message.
 504 * @private_data_len: Size of the private data buffer, in bytes.
 505 */
 506int ib_send_cm_lap(struct ib_cm_id *cm_id,
 507                   struct ib_sa_path_rec *alternate_path,
 508                   const void *private_data,
 509                   u8 private_data_len);
 510
 511/**
 512 * ib_cm_init_qp_attr - Initializes the QP attributes for use in transitioning
 513 *   to a specified QP state.
 514 * @cm_id: Communication identifier associated with the QP attributes to
 515 *   initialize.
 516 * @qp_attr: On input, specifies the desired QP state.  On output, the
 517 *   mandatory and desired optional attributes will be set in order to
 518 *   modify the QP to the specified state.
 519 * @qp_attr_mask: The QP attribute mask that may be used to transition the
 520 *   QP to the specified state.
 521 *
 522 * Users must set the @qp_attr->qp_state to the desired QP state.  This call
 523 * will set all required attributes for the given transition, along with
 524 * known optional attributes.  Users may override the attributes returned from
 525 * this call before calling ib_modify_qp.
 526 */
 527int ib_cm_init_qp_attr(struct ib_cm_id *cm_id,
 528                       struct ib_qp_attr *qp_attr,
 529                       int *qp_attr_mask);
 530
 531/**
 532 * ib_send_cm_apr - Sends an alternate path response message in response to
 533 *   a load alternate path request.
 534 * @cm_id: Connection identifier associated with the alternate path response.
 535 * @status: Reply status sent with the alternate path response.
 536 * @info: Optional additional information sent with the alternate path
 537 *   response.
 538 * @info_length: Size of the additional information, in bytes.
 539 * @private_data: Optional user-defined private data sent with the
 540 *   alternate path response message.
 541 * @private_data_len: Size of the private data buffer, in bytes.
 542 */
 543int ib_send_cm_apr(struct ib_cm_id *cm_id,
 544                   enum ib_cm_apr_status status,
 545                   void *info,
 546                   u8 info_length,
 547                   const void *private_data,
 548                   u8 private_data_len);
 549
 550struct ib_cm_sidr_req_param {
 551        struct ib_sa_path_rec   *path;
 552        __be64                  service_id;
 553        int                     timeout_ms;
 554        const void              *private_data;
 555        u8                      private_data_len;
 556        u8                      max_cm_retries;
 557};
 558
 559/**
 560 * ib_send_cm_sidr_req - Sends a service ID resolution request to the
 561 *   remote node.
 562 * @cm_id: Communication identifier that will be associated with the
 563 *   service ID resolution request.
 564 * @param: Service ID resolution request information.
 565 */
 566int ib_send_cm_sidr_req(struct ib_cm_id *cm_id,
 567                        struct ib_cm_sidr_req_param *param);
 568
 569struct ib_cm_sidr_rep_param {
 570        u32                     qp_num;
 571        u32                     qkey;
 572        enum ib_cm_sidr_status  status;
 573        const void              *info;
 574        u8                      info_length;
 575        const void              *private_data;
 576        u8                      private_data_len;
 577};
 578
 579/**
 580 * ib_send_cm_sidr_rep - Sends a service ID resolution reply to the
 581 *   remote node.
 582 * @cm_id: Communication identifier associated with the received service ID
 583 *   resolution request.
 584 * @param: Service ID resolution reply information.
 585 */
 586int ib_send_cm_sidr_rep(struct ib_cm_id *cm_id,
 587                        struct ib_cm_sidr_rep_param *param);
 588
 589#endif /* IB_CM_H */
 590
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.