394 lines · c
1/* SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB */2/*3 * Copyright (c) 2005 Voltaire Inc. All rights reserved.4 * Copyright (c) 2005 Intel Corporation. All rights reserved.5 */6 7#ifndef RDMA_CM_H8#define RDMA_CM_H9 10#include <linux/socket.h>11#include <linux/in6.h>12#include <rdma/ib_addr.h>13#include <rdma/ib_sa.h>14#include <uapi/rdma/rdma_user_cm.h>15 16/*17 * Upon receiving a device removal event, users must destroy the associated18 * RDMA identifier and release all resources allocated with the device.19 */20enum rdma_cm_event_type {21 RDMA_CM_EVENT_ADDR_RESOLVED,22 RDMA_CM_EVENT_ADDR_ERROR,23 RDMA_CM_EVENT_ROUTE_RESOLVED,24 RDMA_CM_EVENT_ROUTE_ERROR,25 RDMA_CM_EVENT_CONNECT_REQUEST,26 RDMA_CM_EVENT_CONNECT_RESPONSE,27 RDMA_CM_EVENT_CONNECT_ERROR,28 RDMA_CM_EVENT_UNREACHABLE,29 RDMA_CM_EVENT_REJECTED,30 RDMA_CM_EVENT_ESTABLISHED,31 RDMA_CM_EVENT_DISCONNECTED,32 RDMA_CM_EVENT_DEVICE_REMOVAL,33 RDMA_CM_EVENT_MULTICAST_JOIN,34 RDMA_CM_EVENT_MULTICAST_ERROR,35 RDMA_CM_EVENT_ADDR_CHANGE,36 RDMA_CM_EVENT_TIMEWAIT_EXIT37};38 39const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event);40 41#define RDMA_IB_IP_PS_MASK 0xFFFFFFFFFFFF0000ULL42#define RDMA_IB_IP_PS_TCP 0x0000000001060000ULL43#define RDMA_IB_IP_PS_UDP 0x0000000001110000ULL44#define RDMA_IB_IP_PS_IB 0x00000000013F0000ULL45 46struct rdma_addr {47 struct sockaddr_storage src_addr;48 struct sockaddr_storage dst_addr;49 struct rdma_dev_addr dev_addr;50};51 52struct rdma_route {53 struct rdma_addr addr;54 struct sa_path_rec *path_rec;55 56 /* Optional path records of primary path */57 struct sa_path_rec *path_rec_inbound;58 struct sa_path_rec *path_rec_outbound;59 60 /*61 * 0 - No primary nor alternate path is available62 * 1 - Only primary path is available63 * 2 - Both primary and alternate path are available64 */65 int num_pri_alt_paths;66};67 68struct rdma_conn_param {69 const void *private_data;70 u8 private_data_len;71 u8 responder_resources;72 u8 initiator_depth;73 u8 flow_control;74 u8 retry_count; /* ignored when accepting */75 u8 rnr_retry_count;76 /* Fields below ignored if a QP is created on the rdma_cm_id. */77 u8 srq;78 u32 qp_num;79 u32 qkey;80};81 82struct rdma_ud_param {83 const void *private_data;84 u8 private_data_len;85 struct rdma_ah_attr ah_attr;86 u32 qp_num;87 u32 qkey;88};89 90struct rdma_cm_event {91 enum rdma_cm_event_type event;92 int status;93 union {94 struct rdma_conn_param conn;95 struct rdma_ud_param ud;96 } param;97 struct rdma_ucm_ece ece;98};99 100struct rdma_cm_id;101 102/**103 * rdma_cm_event_handler - Callback used to report user events.104 *105 * Notes: Users may not call rdma_destroy_id from this callback to destroy106 * the passed in id, or a corresponding listen id. Returning a107 * non-zero value from the callback will destroy the passed in id.108 */109typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id,110 struct rdma_cm_event *event);111 112struct rdma_cm_id {113 struct ib_device *device;114 void *context;115 struct ib_qp *qp;116 rdma_cm_event_handler event_handler;117 struct rdma_route route;118 enum rdma_ucm_port_space ps;119 enum ib_qp_type qp_type;120 u32 port_num;121 struct work_struct net_work;122};123 124struct rdma_cm_id *125__rdma_create_kernel_id(struct net *net, rdma_cm_event_handler event_handler,126 void *context, enum rdma_ucm_port_space ps,127 enum ib_qp_type qp_type, const char *caller);128struct rdma_cm_id *rdma_create_user_id(rdma_cm_event_handler event_handler,129 void *context,130 enum rdma_ucm_port_space ps,131 enum ib_qp_type qp_type);132 133/**134 * rdma_create_id - Create an RDMA identifier.135 *136 * @net: The network namespace in which to create the new id.137 * @event_handler: User callback invoked to report events associated with the138 * returned rdma_id.139 * @context: User specified context associated with the id.140 * @ps: RDMA port space.141 * @qp_type: type of queue pair associated with the id.142 *143 * Returns a new rdma_cm_id. The id holds a reference on the network144 * namespace until it is destroyed.145 *146 * The event handler callback serializes on the id's mutex and is147 * allowed to sleep.148 */149#define rdma_create_id(net, event_handler, context, ps, qp_type) \150 __rdma_create_kernel_id(net, event_handler, context, ps, qp_type, \151 KBUILD_MODNAME)152 153/**154 * rdma_destroy_id - Destroys an RDMA identifier.155 *156 * @id: RDMA identifier.157 *158 * Note: calling this function has the effect of canceling in-flight159 * asynchronous operations associated with the id.160 */161void rdma_destroy_id(struct rdma_cm_id *id);162 163/**164 * rdma_bind_addr - Bind an RDMA identifier to a source address and165 * associated RDMA device, if needed.166 *167 * @id: RDMA identifier.168 * @addr: Local address information. Wildcard values are permitted.169 *170 * This associates a source address with the RDMA identifier before calling171 * rdma_listen. If a specific local address is given, the RDMA identifier will172 * be bound to a local RDMA device.173 */174int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);175 176/**177 * rdma_resolve_addr - Resolve destination and optional source addresses178 * from IP addresses to an RDMA address. If successful, the specified179 * rdma_cm_id will be bound to a local device.180 *181 * @id: RDMA identifier.182 * @src_addr: Source address information. This parameter may be NULL.183 * @dst_addr: Destination address information.184 * @timeout_ms: Time to wait for resolution to complete.185 */186int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,187 const struct sockaddr *dst_addr,188 unsigned long timeout_ms);189 190/**191 * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier192 * into route information needed to establish a connection.193 *194 * This is called on the client side of a connection.195 * Users must have first called rdma_resolve_addr to resolve a dst_addr196 * into an RDMA address before calling this routine.197 */198int rdma_resolve_route(struct rdma_cm_id *id, unsigned long timeout_ms);199 200/**201 * rdma_create_qp - Allocate a QP and associate it with the specified RDMA202 * identifier.203 *204 * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA205 * through their states.206 */207int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,208 struct ib_qp_init_attr *qp_init_attr);209 210/**211 * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA212 * identifier.213 *214 * Users must destroy any QP associated with an RDMA identifier before215 * destroying the RDMA ID.216 */217void rdma_destroy_qp(struct rdma_cm_id *id);218 219/**220 * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning221 * to a specified QP state.222 * @id: Communication identifier associated with the QP attributes to223 * initialize.224 * @qp_attr: On input, specifies the desired QP state. On output, the225 * mandatory and desired optional attributes will be set in order to226 * modify the QP to the specified state.227 * @qp_attr_mask: The QP attribute mask that may be used to transition the228 * QP to the specified state.229 *230 * Users must set the @qp_attr->qp_state to the desired QP state. This call231 * will set all required attributes for the given transition, along with232 * known optional attributes. Users may override the attributes returned from233 * this call before calling ib_modify_qp.234 *235 * Users that wish to have their QP automatically transitioned through its236 * states can associate a QP with the rdma_cm_id by calling rdma_create_qp().237 */238int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,239 int *qp_attr_mask);240 241int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);242int rdma_connect_locked(struct rdma_cm_id *id,243 struct rdma_conn_param *conn_param);244 245int rdma_connect_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,246 struct rdma_ucm_ece *ece);247 248/**249 * rdma_listen - This function is called by the passive side to250 * listen for incoming connection requests.251 *252 * Users must have bound the rdma_cm_id to a local address by calling253 * rdma_bind_addr before calling this routine.254 */255int rdma_listen(struct rdma_cm_id *id, int backlog);256 257int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);258 259void rdma_lock_handler(struct rdma_cm_id *id);260void rdma_unlock_handler(struct rdma_cm_id *id);261int rdma_accept_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,262 struct rdma_ucm_ece *ece);263 264/**265 * rdma_notify - Notifies the RDMA CM of an asynchronous event that has266 * occurred on the connection.267 * @id: Connection identifier to transition to established.268 * @event: Asynchronous event.269 *270 * This routine should be invoked by users to notify the CM of relevant271 * communication events. Events that should be reported to the CM and272 * when to report them are:273 *274 * IB_EVENT_COMM_EST - Used when a message is received on a connected275 * QP before an RTU has been received.276 */277int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);278 279/**280 * rdma_reject - Called to reject a connection request or response.281 */282int rdma_reject(struct rdma_cm_id *id, const void *private_data,283 u8 private_data_len, u8 reason);284 285/**286 * rdma_disconnect - This function disconnects the associated QP and287 * transitions it into the error state.288 */289int rdma_disconnect(struct rdma_cm_id *id);290 291/**292 * rdma_join_multicast - Join the multicast group specified by the given293 * address.294 * @id: Communication identifier associated with the request.295 * @addr: Multicast address identifying the group to join.296 * @join_state: Multicast JoinState bitmap requested by port.297 * Bitmap is based on IB_SA_MCMEMBER_REC_JOIN_STATE bits.298 * @context: User-defined context associated with the join request, returned299 * to the user through the private_data pointer in multicast events.300 */301int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,302 u8 join_state, void *context);303 304/**305 * rdma_leave_multicast - Leave the multicast group specified by the given306 * address.307 */308void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);309 310/**311 * rdma_set_service_type - Set the type of service associated with a312 * connection identifier.313 * @id: Communication identifier to associated with service type.314 * @tos: Type of service.315 *316 * The type of service is interpretted as a differentiated service317 * field (RFC 2474). The service type should be specified before318 * performing route resolution, as existing communication on the319 * connection identifier may be unaffected. The type of service320 * requested may not be supported by the network to all destinations.321 */322void rdma_set_service_type(struct rdma_cm_id *id, int tos);323 324/**325 * rdma_set_reuseaddr - Allow the reuse of local addresses when binding326 * the rdma_cm_id.327 * @id: Communication identifier to configure.328 * @reuse: Value indicating if the bound address is reusable.329 *330 * Reuse must be set before an address is bound to the id.331 */332int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse);333 334/**335 * rdma_set_afonly - Specify that listens are restricted to the336 * bound address family only.337 * @id: Communication identifer to configure.338 * @afonly: Value indicating if listens are restricted.339 *340 * Must be set before identifier is in the listening state.341 */342int rdma_set_afonly(struct rdma_cm_id *id, int afonly);343 344int rdma_set_ack_timeout(struct rdma_cm_id *id, u8 timeout);345 346int rdma_set_min_rnr_timer(struct rdma_cm_id *id, u8 min_rnr_timer);347 /**348 * rdma_get_service_id - Return the IB service ID for a specified address.349 * @id: Communication identifier associated with the address.350 * @addr: Address for the service ID.351 */352__be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr);353 354/**355 * rdma_reject_msg - return a pointer to a reject message string.356 * @id: Communication identifier that received the REJECT event.357 * @reason: Value returned in the REJECT event status field.358 */359const char *__attribute_const__ rdma_reject_msg(struct rdma_cm_id *id,360 int reason);361/**362 * rdma_consumer_reject_data - return the consumer reject private data and363 * length, if any.364 * @id: Communication identifier that received the REJECT event.365 * @ev: RDMA CM reject event.366 * @data_len: Pointer to the resulting length of the consumer data.367 */368const void *rdma_consumer_reject_data(struct rdma_cm_id *id,369 struct rdma_cm_event *ev, u8 *data_len);370 371/**372 * rdma_read_gids - Return the SGID and DGID used for establishing373 * connection. This can be used after rdma_resolve_addr()374 * on client side. This can be use on new connection375 * on server side. This is applicable to IB, RoCE, iWarp.376 * If cm_id is not bound yet to the RDMA device, it doesn't377 * copy and SGID or DGID to the given pointers.378 * @id: Communication identifier whose GIDs are queried.379 * @sgid: Pointer to SGID where SGID will be returned. It is optional.380 * @dgid: Pointer to DGID where DGID will be returned. It is optional.381 * Note: This API should not be used by any new ULPs or new code.382 * Instead, users interested in querying GIDs should refer to path record383 * of the rdma_cm_id to query the GIDs.384 * This API is provided for compatibility for existing users.385 */386 387void rdma_read_gids(struct rdma_cm_id *cm_id, union ib_gid *sgid,388 union ib_gid *dgid);389 390struct iw_cm_id *rdma_iw_cm_id(struct rdma_cm_id *cm_id);391struct rdma_cm_id *rdma_res_to_id(struct rdma_restrack_entry *res);392 393#endif /* RDMA_CM_H */394