1 /*
   2  * This file contains definitions used in OFED defined user/kernel
   3  * interfaces. These are imported from the OFED header rdma_cm.h. Oracle
   4  * elects to have and use the contents of rdma_cm.h under and governed
   5  * by the OpenIB.org BSD license (see below for details). However,
   6  * the following notice accompanied the original version of this file:
   7  */
   8 
   9 /*
  10  * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
  11  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
  12  *
  13  * This Software is licensed under one of the following licenses:
  14  *
  15  * 1) under the terms of the "Common Public License 1.0" a copy of which is
  16  *    available from the Open Source Initiative, see
  17  *    http://www.opensource.org/licenses/cpl.php.
  18  *
  19  * 2) under the terms of the "The BSD License" a copy of which is
  20  *    available from the Open Source Initiative, see
  21  *    http://www.opensource.org/licenses/bsd-license.php.
  22  *
  23  * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
  24  *    copy of which is available from the Open Source Initiative, see
  25  *    http://www.opensource.org/licenses/gpl-license.php.
  26  *
  27  * Licensee has the right to choose one of the above licenses.
  28  *
  29  * Redistributions of source code must retain the above copyright
  30  * notice and one of the license notices.
  31  *
  32  * Redistributions in binary form must reproduce both the above copyright
  33  * notice, one of the license notices in the documentation
  34  * and/or other materials provided with the distribution.
  35  *
  36  */
  37 
  38 #ifndef _SYS_IB_CLIENTS_OF_RDMA_RDMA_CM_H
  39 #define _SYS_IB_CLIENTS_OF_RDMA_RDMA_CM_H
  40 
  41 #ifdef __cplusplus
  42 extern "C" {
  43 #endif
  44 
  45 #include <sys/socket.h>
  46 
  47 /*
  48  * Upon receiving a device removal event, users must destroy the associated
  49  * RDMA identifier and release all resources allocated with the device.
  50  */
  51 enum rdma_cm_event_type {
  52         RDMA_CM_EVENT_ADDR_RESOLVED,
  53         RDMA_CM_EVENT_ADDR_ERROR,
  54         RDMA_CM_EVENT_ROUTE_RESOLVED,
  55         RDMA_CM_EVENT_ROUTE_ERROR,
  56         RDMA_CM_EVENT_CONNECT_REQUEST,
  57         RDMA_CM_EVENT_CONNECT_RESPONSE,
  58         RDMA_CM_EVENT_CONNECT_ERROR,
  59         RDMA_CM_EVENT_UNREACHABLE,
  60         RDMA_CM_EVENT_REJECTED,
  61         RDMA_CM_EVENT_ESTABLISHED,
  62         RDMA_CM_EVENT_DISCONNECTED,
  63         RDMA_CM_EVENT_DEVICE_REMOVAL,
  64         RDMA_CM_EVENT_MULTICAST_JOIN,
  65         RDMA_CM_EVENT_MULTICAST_ERROR,
  66         RDMA_CM_EVENT_ADDR_CHANGE
  67 };
  68 
  69 enum rdma_port_space {
  70         RDMA_PS_SDP  = 0x0001,
  71         RDMA_PS_IPOIB = 0x0002,
  72         RDMA_PS_TCP  = 0x0106,
  73         RDMA_PS_UDP  = 0x0111,
  74         RDMA_PS_SCTP = 0x0183
  75 };
  76 
  77 struct rdma_addr {
  78         struct sockaddr src_addr;
  79         uint8_t         src_pad[sizeof (struct sockaddr_in6) -
  80                                 sizeof (struct sockaddr)];
  81         struct sockaddr dst_addr;
  82         uint8_t         dst_pad[sizeof (struct sockaddr_in6) -
  83                                 sizeof (struct sockaddr)];
  84         struct rdma_dev_addr dev_addr;
  85 };
  86 
  87 struct rdma_route {
  88         struct rdma_addr addr;
  89         struct ib_sa_path_rec *path_rec;
  90         int num_paths;
  91 };
  92 
  93 struct rdma_conn_param {
  94         const void *private_data;
  95         uint8_t private_data_len;
  96         uint8_t responder_resources;
  97         uint8_t initiator_depth;
  98         uint8_t flow_control;
  99         uint8_t retry_count;            /* ignored when accepting */
 100         uint8_t rnr_retry_count;
 101         /* Fields below ignored if a QP is created on the rdma_cm_id. */
 102         uint8_t srq;
 103         uint32_t qp_num;
 104 };
 105 
 106 struct rdma_ud_param {
 107         const void *private_data;
 108         uint8_t private_data_len;
 109         struct ib_ah_attr ah_attr;
 110         uint32_t qp_num;
 111         uint32_t qkey;
 112 };
 113 
 114 struct rdma_cm_event {
 115         enum rdma_cm_event_type  event;
 116         int                      status;
 117         union {
 118                 struct rdma_conn_param  conn;
 119                 struct rdma_ud_param    ud;
 120         } param;
 121 };
 122 
 123 struct rdma_cm_id;
 124 
 125 /*
 126  * rdma_cm_event_handler - Callback used to report user events.
 127  *
 128  * Notes: Users may not call rdma_destroy_id from this callback to destroy
 129  *   the passed in id, or a corresponding listen id.  Returning a
 130  *   non-zero value from the callback will destroy the passed in id.
 131  */
 132 typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id,
 133                                                 struct rdma_cm_event *event);
 134 
 135 struct rdma_cm_id {
 136         struct ib_device        *device;
 137         void                    *context;
 138         struct ib_qp            *qp;
 139         rdma_cm_event_handler    event_handler;
 140         struct rdma_route        route;
 141         enum rdma_port_space     ps;
 142         uint8_t                  port_num;
 143 };
 144 
 145 /*
 146  * rdma_create_id - Create an RDMA identifier.
 147  *
 148  * @event_handler: User callback invoked to report events associated with the
 149  *   returned rdma_id.
 150  * @context: User specified context associated with the id.
 151  * @ps: RDMA port space.
 152  */
 153 struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler,
 154     void *context, enum rdma_port_space ps);
 155 
 156 /*
 157  * rdma_map_id2clnthdl -
 158  *      Maps RDMA identifier with IBTF and / or ROF client handles. Either
 159  *      of the handles can be NULL, but both should not be NULL. This API
 160  *      is called just after calling rdma_create_id() on the passive side.
 161  *
 162  * rdma_map_id2qphdl -
 163  *      This is used to map RDMA-CM ID to IBTF or ROF client handle and
 164  *      the QP handle. This is called by the passive side just after
 165  *      rdma_create_id() and on the active side just before rdma_accept()
 166  *      in the CONNECTION_REQUEST event handler.
 167  */
 168 void rdma_map_id2clnthdl(struct rdma_cm_id *id, void *ib_client_hdl,
 169     void *iw_client_hdl);
 170 void rdma_map_id2qphdl(struct rdma_cm_id *id, void *qp_hdl);
 171 
 172 /*
 173  * rdma_destroy_id - Destroys an RDMA identifier.
 174  *
 175  * @id: RDMA identifier.
 176  *
 177  * Note: calling this function has the effect of canceling in-flight
 178  * asynchronous operations associated with the id.
 179  */
 180 void rdma_destroy_id(struct rdma_cm_id *id);
 181 
 182 /*
 183  * rdma_bind_addr - Bind an RDMA identifier to a source address and
 184  *   associated RDMA device, if needed.
 185  *
 186  * @id: RDMA identifier.
 187  * @addr: Local address information.  Wildcard values are permitted.
 188  *
 189  * This associates a source address with the RDMA identifier before calling
 190  * rdma_listen.  If a specific local address is given, the RDMA identifier will
 191  * be bound to a local RDMA device.
 192  */
 193 int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);
 194 
 195 /*
 196  * rdma_resolve_addr - Resolve destination and optional source addresses
 197  *   from IP addresses to an RDMA address.  If successful, the specified
 198  *   rdma_cm_id will be bound to a local device.
 199  *
 200  * @id: RDMA identifier.
 201  * @src_addr: Source address information.  This parameter may be NULL.
 202  * @dst_addr: Destination address information.
 203  * @timeout_ms: Time to wait for resolution to complete.
 204  */
 205 int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
 206                                 struct sockaddr *dst_addr, int timeout_ms);
 207 
 208 /*
 209  * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier
 210  *   into route information needed to establish a connection.
 211  *
 212  * This is called on the client side of a connection.
 213  * Users must have first called rdma_resolve_addr to resolve a dst_addr
 214  * into an RDMA address before calling this routine.
 215  */
 216 int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms);
 217 
 218 
 219 /*
 220  * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning
 221  *   to a specified QP state.
 222  * @id: Communication identifier associated with the QP attributes to
 223  *   initialize.
 224  * @qp_attr: On input, specifies the desired QP state.  On output, the
 225  *   mandatory and desired optional attributes will be set in order to
 226  *   modify the QP to the specified state.
 227  * @qp_attr_mask: The QP attribute mask that may be used to transition the
 228  *   QP to the specified state.
 229  *
 230  * Users must set the @qp_attr->qp_state to the desired QP state.  This call
 231  * will set all required attributes for the given transition, along with
 232  * known optional attributes.  Users may override the attributes returned from
 233  * this call before calling ib_modify_qp.
 234  *
 235  * Users that wish to have their QP automatically transitioned through its
 236  * states can associate a QP with the rdma_cm_id by calling rdma_create_qp().
 237  */
 238 int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
 239                                                         int *qp_attr_mask);
 240 /*
 241  * rdma_connect - Initiate an active connection request.
 242  * @id: Connection identifier to connect.
 243  * @conn_param: Connection information used for connected QPs.
 244  *
 245  * Users must have resolved a route for the rdma_cm_id to connect with
 246  * by having called rdma_resolve_route before calling this routine.
 247  *
 248  * This call will either connect to a remote QP or obtain remote QP
 249  * information for unconnected rdma_cm_id's.  The actual operation is
 250  * based on the rdma_cm_id's port space.
 251  */
 252 int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
 253 
 254 /*
 255  * rdma_listen - This function is called by the passive side to
 256  *   listen for incoming connection requests.
 257  *
 258  * Users must have bound the rdma_cm_id to a local address by calling
 259  * rdma_bind_addr before calling this routine.
 260  */
 261 int rdma_listen(struct rdma_cm_id *id, int backlog);
 262 
 263 /*
 264  * rdma_accept - Called to accept a connection request or response.
 265  * @id: Connection identifier associated with the request.
 266  * @conn_param: Information needed to establish the connection.  This must be
 267  *   provided if accepting a connection request.  If accepting a connection
 268  *   response, this parameter must be NULL.
 269  *
 270  * Typically, this routine is only called by the listener to accept a connection
 271  * request.  It must also be called on the active side of a connection if the
 272  * user is performing their own QP transitions.
 273  *
 274  * In the case of error, a reject message is sent to the remote side and the
 275  * state of the qp associated with the id is modified to error, such that any
 276  * previously posted receive buffers would be flushed.
 277  */
 278 int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
 279 
 280 /*
 281  * rdma_notify - Notifies the RDMA CM of an asynchronous event that has
 282  * occurred on the connection.
 283  * @id: Connection identifier to transition to established.
 284  * @event: Asynchronous event.
 285  *
 286  * This routine should be invoked by users to notify the CM of relevant
 287  * communication events.  Events that should be reported to the CM and
 288  * when to report them are:
 289  *
 290  * IB_EVENT_COMM_EST - Used when a message is received on a connected
 291  *    QP before an RTU has been received.
 292  */
 293 int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);
 294 
 295 /*
 296  * rdma_reject - Called to reject a connection request or response.
 297  */
 298 int rdma_reject(struct rdma_cm_id *id, const void *private_data,
 299                 uint8_t private_data_len);
 300 
 301 /*
 302  * rdma_disconnect - This function disconnects the associated QP and
 303  *   transitions it into the error state.
 304  */
 305 int rdma_disconnect(struct rdma_cm_id *id);
 306 
 307 /*
 308  * rdma_join_multicast - Join the multicast group specified by the given
 309  *   address.
 310  * @id: Communication identifier associated with the request.
 311  * @addr: Multicast address identifying the group to join.
 312  * @context: User-defined context associated with the join request, returned
 313  * to the user through the private_data pointer in multicast events.
 314  */
 315 int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
 316                         void *context);
 317 
 318 /*
 319  * rdma_leave_multicast - Leave the multicast group specified by the given
 320  *   address.
 321  */
 322 void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);
 323 
 324 /*
 325  * rdma_set_service_type - Set the type of service associated with a
 326  *   connection identifier.
 327  * @id: Communication identifier to associated with service type.
 328  * @tos: Type of service.
 329  *
 330  * The type of service is interpretted as a differentiated service
 331  * field (RFC 2474).  The service type should be specified before
 332  * performing route resolution, as existing communication on the
 333  * connection identifier may be unaffected.  The type of service
 334  * requested may not be supported by the network to all destinations.
 335  */
 336 void rdma_set_service_type(struct rdma_cm_id *id, int tos);
 337 
 338 
 339 /*
 340  * rdma_create_qp - Allocate a QP and associate it with the specified RDMA
 341  * identifier.
 342  *
 343  * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA
 344  * through their states.
 345  */
 346 int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
 347     struct ib_qp_init_attr *qp_init_attr);
 348 
 349 /*
 350  * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA
 351  * identifier.
 352  *
 353  * Users must destroy any QP associated with an RDMA identifier before
 354  * destroying the RDMA ID.
 355  */
 356 void rdma_destroy_qp(struct rdma_cm_id *id);
 357 
 358 #ifdef __cplusplus
 359 }
 360 #endif
 361 #endif /* _SYS_IB_CLIENTS_OF_RDMA_RDMA_CM_H */