rdma_cm.h 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380
  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. #ifndef RDMA_CM_H
  7. #define RDMA_CM_H
  8. #include <linux/socket.h>
  9. #include <linux/in6.h>
  10. #include <rdma/ib_addr.h>
  11. #include <rdma/ib_sa.h>
  12. #include <uapi/rdma/rdma_user_cm.h>
  13. /*
  14. * Upon receiving a device removal event, users must destroy the associated
  15. * RDMA identifier and release all resources allocated with the device.
  16. */
  17. enum rdma_cm_event_type {
  18. RDMA_CM_EVENT_ADDR_RESOLVED,
  19. RDMA_CM_EVENT_ADDR_ERROR,
  20. RDMA_CM_EVENT_ROUTE_RESOLVED,
  21. RDMA_CM_EVENT_ROUTE_ERROR,
  22. RDMA_CM_EVENT_CONNECT_REQUEST,
  23. RDMA_CM_EVENT_CONNECT_RESPONSE,
  24. RDMA_CM_EVENT_CONNECT_ERROR,
  25. RDMA_CM_EVENT_UNREACHABLE,
  26. RDMA_CM_EVENT_REJECTED,
  27. RDMA_CM_EVENT_ESTABLISHED,
  28. RDMA_CM_EVENT_DISCONNECTED,
  29. RDMA_CM_EVENT_DEVICE_REMOVAL,
  30. RDMA_CM_EVENT_MULTICAST_JOIN,
  31. RDMA_CM_EVENT_MULTICAST_ERROR,
  32. RDMA_CM_EVENT_ADDR_CHANGE,
  33. RDMA_CM_EVENT_TIMEWAIT_EXIT
  34. };
  35. const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event);
  36. #define RDMA_IB_IP_PS_MASK 0xFFFFFFFFFFFF0000ULL
  37. #define RDMA_IB_IP_PS_TCP 0x0000000001060000ULL
  38. #define RDMA_IB_IP_PS_UDP 0x0000000001110000ULL
  39. #define RDMA_IB_IP_PS_IB 0x00000000013F0000ULL
  40. struct rdma_addr {
  41. struct sockaddr_storage src_addr;
  42. struct sockaddr_storage dst_addr;
  43. struct rdma_dev_addr dev_addr;
  44. };
  45. struct rdma_route {
  46. struct rdma_addr addr;
  47. struct sa_path_rec *path_rec;
  48. int num_paths;
  49. };
  50. struct rdma_conn_param {
  51. const void *private_data;
  52. u8 private_data_len;
  53. u8 responder_resources;
  54. u8 initiator_depth;
  55. u8 flow_control;
  56. u8 retry_count; /* ignored when accepting */
  57. u8 rnr_retry_count;
  58. /* Fields below ignored if a QP is created on the rdma_cm_id. */
  59. u8 srq;
  60. u32 qp_num;
  61. u32 qkey;
  62. };
  63. struct rdma_ud_param {
  64. const void *private_data;
  65. u8 private_data_len;
  66. struct rdma_ah_attr ah_attr;
  67. u32 qp_num;
  68. u32 qkey;
  69. };
  70. struct rdma_cm_event {
  71. enum rdma_cm_event_type event;
  72. int status;
  73. union {
  74. struct rdma_conn_param conn;
  75. struct rdma_ud_param ud;
  76. } param;
  77. struct rdma_ucm_ece ece;
  78. };
  79. struct rdma_cm_id;
  80. /**
  81. * rdma_cm_event_handler - Callback used to report user events.
  82. *
  83. * Notes: Users may not call rdma_destroy_id from this callback to destroy
  84. * the passed in id, or a corresponding listen id. Returning a
  85. * non-zero value from the callback will destroy the passed in id.
  86. */
  87. typedef int (*rdma_cm_event_handler)(struct rdma_cm_id *id,
  88. struct rdma_cm_event *event);
  89. struct rdma_cm_id {
  90. struct ib_device *device;
  91. void *context;
  92. struct ib_qp *qp;
  93. rdma_cm_event_handler event_handler;
  94. struct rdma_route route;
  95. enum rdma_ucm_port_space ps;
  96. enum ib_qp_type qp_type;
  97. u8 port_num;
  98. };
  99. struct rdma_cm_id *
  100. __rdma_create_kernel_id(struct net *net, rdma_cm_event_handler event_handler,
  101. void *context, enum rdma_ucm_port_space ps,
  102. enum ib_qp_type qp_type, const char *caller);
  103. struct rdma_cm_id *rdma_create_user_id(rdma_cm_event_handler event_handler,
  104. void *context,
  105. enum rdma_ucm_port_space ps,
  106. enum ib_qp_type qp_type);
  107. /**
  108. * rdma_create_id - Create an RDMA identifier.
  109. *
  110. * @net: The network namespace in which to create the new id.
  111. * @event_handler: User callback invoked to report events associated with the
  112. * returned rdma_id.
  113. * @context: User specified context associated with the id.
  114. * @ps: RDMA port space.
  115. * @qp_type: type of queue pair associated with the id.
  116. *
  117. * Returns a new rdma_cm_id. The id holds a reference on the network
  118. * namespace until it is destroyed.
  119. *
  120. * The event handler callback serializes on the id's mutex and is
  121. * allowed to sleep.
  122. */
  123. #define rdma_create_id(net, event_handler, context, ps, qp_type) \
  124. __rdma_create_kernel_id(net, event_handler, context, ps, qp_type, \
  125. KBUILD_MODNAME)
  126. /**
  127. * rdma_destroy_id - Destroys an RDMA identifier.
  128. *
  129. * @id: RDMA identifier.
  130. *
  131. * Note: calling this function has the effect of canceling in-flight
  132. * asynchronous operations associated with the id.
  133. */
  134. void rdma_destroy_id(struct rdma_cm_id *id);
  135. /**
  136. * rdma_bind_addr - Bind an RDMA identifier to a source address and
  137. * associated RDMA device, if needed.
  138. *
  139. * @id: RDMA identifier.
  140. * @addr: Local address information. Wildcard values are permitted.
  141. *
  142. * This associates a source address with the RDMA identifier before calling
  143. * rdma_listen. If a specific local address is given, the RDMA identifier will
  144. * be bound to a local RDMA device.
  145. */
  146. int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr);
  147. /**
  148. * rdma_resolve_addr - Resolve destination and optional source addresses
  149. * from IP addresses to an RDMA address. If successful, the specified
  150. * rdma_cm_id will be bound to a local device.
  151. *
  152. * @id: RDMA identifier.
  153. * @src_addr: Source address information. This parameter may be NULL.
  154. * @dst_addr: Destination address information.
  155. * @timeout_ms: Time to wait for resolution to complete.
  156. */
  157. int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
  158. const struct sockaddr *dst_addr,
  159. unsigned long timeout_ms);
  160. /**
  161. * rdma_resolve_route - Resolve the RDMA address bound to the RDMA identifier
  162. * into route information needed to establish a connection.
  163. *
  164. * This is called on the client side of a connection.
  165. * Users must have first called rdma_resolve_addr to resolve a dst_addr
  166. * into an RDMA address before calling this routine.
  167. */
  168. int rdma_resolve_route(struct rdma_cm_id *id, unsigned long timeout_ms);
  169. /**
  170. * rdma_create_qp - Allocate a QP and associate it with the specified RDMA
  171. * identifier.
  172. *
  173. * QPs allocated to an rdma_cm_id will automatically be transitioned by the CMA
  174. * through their states.
  175. */
  176. int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
  177. struct ib_qp_init_attr *qp_init_attr);
  178. /**
  179. * rdma_destroy_qp - Deallocate the QP associated with the specified RDMA
  180. * identifier.
  181. *
  182. * Users must destroy any QP associated with an RDMA identifier before
  183. * destroying the RDMA ID.
  184. */
  185. void rdma_destroy_qp(struct rdma_cm_id *id);
  186. /**
  187. * rdma_init_qp_attr - Initializes the QP attributes for use in transitioning
  188. * to a specified QP state.
  189. * @id: Communication identifier associated with the QP attributes to
  190. * initialize.
  191. * @qp_attr: On input, specifies the desired QP state. On output, the
  192. * mandatory and desired optional attributes will be set in order to
  193. * modify the QP to the specified state.
  194. * @qp_attr_mask: The QP attribute mask that may be used to transition the
  195. * QP to the specified state.
  196. *
  197. * Users must set the @qp_attr->qp_state to the desired QP state. This call
  198. * will set all required attributes for the given transition, along with
  199. * known optional attributes. Users may override the attributes returned from
  200. * this call before calling ib_modify_qp.
  201. *
  202. * Users that wish to have their QP automatically transitioned through its
  203. * states can associate a QP with the rdma_cm_id by calling rdma_create_qp().
  204. */
  205. int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
  206. int *qp_attr_mask);
  207. int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
  208. int rdma_connect_locked(struct rdma_cm_id *id,
  209. struct rdma_conn_param *conn_param);
  210. int rdma_connect_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,
  211. struct rdma_ucm_ece *ece);
  212. /**
  213. * rdma_listen - This function is called by the passive side to
  214. * listen for incoming connection requests.
  215. *
  216. * Users must have bound the rdma_cm_id to a local address by calling
  217. * rdma_bind_addr before calling this routine.
  218. */
  219. int rdma_listen(struct rdma_cm_id *id, int backlog);
  220. int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param);
  221. void rdma_lock_handler(struct rdma_cm_id *id);
  222. void rdma_unlock_handler(struct rdma_cm_id *id);
  223. int rdma_accept_ece(struct rdma_cm_id *id, struct rdma_conn_param *conn_param,
  224. struct rdma_ucm_ece *ece);
  225. /**
  226. * rdma_notify - Notifies the RDMA CM of an asynchronous event that has
  227. * occurred on the connection.
  228. * @id: Connection identifier to transition to established.
  229. * @event: Asynchronous event.
  230. *
  231. * This routine should be invoked by users to notify the CM of relevant
  232. * communication events. Events that should be reported to the CM and
  233. * when to report them are:
  234. *
  235. * IB_EVENT_COMM_EST - Used when a message is received on a connected
  236. * QP before an RTU has been received.
  237. */
  238. int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event);
  239. /**
  240. * rdma_reject - Called to reject a connection request or response.
  241. */
  242. int rdma_reject(struct rdma_cm_id *id, const void *private_data,
  243. u8 private_data_len, u8 reason);
  244. /**
  245. * rdma_disconnect - This function disconnects the associated QP and
  246. * transitions it into the error state.
  247. */
  248. int rdma_disconnect(struct rdma_cm_id *id);
  249. /**
  250. * rdma_join_multicast - Join the multicast group specified by the given
  251. * address.
  252. * @id: Communication identifier associated with the request.
  253. * @addr: Multicast address identifying the group to join.
  254. * @join_state: Multicast JoinState bitmap requested by port.
  255. * Bitmap is based on IB_SA_MCMEMBER_REC_JOIN_STATE bits.
  256. * @context: User-defined context associated with the join request, returned
  257. * to the user through the private_data pointer in multicast events.
  258. */
  259. int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
  260. u8 join_state, void *context);
  261. /**
  262. * rdma_leave_multicast - Leave the multicast group specified by the given
  263. * address.
  264. */
  265. void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr);
  266. /**
  267. * rdma_set_service_type - Set the type of service associated with a
  268. * connection identifier.
  269. * @id: Communication identifier to associated with service type.
  270. * @tos: Type of service.
  271. *
  272. * The type of service is interpretted as a differentiated service
  273. * field (RFC 2474). The service type should be specified before
  274. * performing route resolution, as existing communication on the
  275. * connection identifier may be unaffected. The type of service
  276. * requested may not be supported by the network to all destinations.
  277. */
  278. void rdma_set_service_type(struct rdma_cm_id *id, int tos);
  279. /**
  280. * rdma_set_reuseaddr - Allow the reuse of local addresses when binding
  281. * the rdma_cm_id.
  282. * @id: Communication identifier to configure.
  283. * @reuse: Value indicating if the bound address is reusable.
  284. *
  285. * Reuse must be set before an address is bound to the id.
  286. */
  287. int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse);
  288. /**
  289. * rdma_set_afonly - Specify that listens are restricted to the
  290. * bound address family only.
  291. * @id: Communication identifer to configure.
  292. * @afonly: Value indicating if listens are restricted.
  293. *
  294. * Must be set before identifier is in the listening state.
  295. */
  296. int rdma_set_afonly(struct rdma_cm_id *id, int afonly);
  297. int rdma_set_ack_timeout(struct rdma_cm_id *id, u8 timeout);
  298. /**
  299. * rdma_get_service_id - Return the IB service ID for a specified address.
  300. * @id: Communication identifier associated with the address.
  301. * @addr: Address for the service ID.
  302. */
  303. __be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr);
  304. /**
  305. * rdma_reject_msg - return a pointer to a reject message string.
  306. * @id: Communication identifier that received the REJECT event.
  307. * @reason: Value returned in the REJECT event status field.
  308. */
  309. const char *__attribute_const__ rdma_reject_msg(struct rdma_cm_id *id,
  310. int reason);
  311. /**
  312. * rdma_consumer_reject_data - return the consumer reject private data and
  313. * length, if any.
  314. * @id: Communication identifier that received the REJECT event.
  315. * @ev: RDMA CM reject event.
  316. * @data_len: Pointer to the resulting length of the consumer data.
  317. */
  318. const void *rdma_consumer_reject_data(struct rdma_cm_id *id,
  319. struct rdma_cm_event *ev, u8 *data_len);
  320. /**
  321. * rdma_read_gids - Return the SGID and DGID used for establishing
  322. * connection. This can be used after rdma_resolve_addr()
  323. * on client side. This can be use on new connection
  324. * on server side. This is applicable to IB, RoCE, iWarp.
  325. * If cm_id is not bound yet to the RDMA device, it doesn't
  326. * copy and SGID or DGID to the given pointers.
  327. * @id: Communication identifier whose GIDs are queried.
  328. * @sgid: Pointer to SGID where SGID will be returned. It is optional.
  329. * @dgid: Pointer to DGID where DGID will be returned. It is optional.
  330. * Note: This API should not be used by any new ULPs or new code.
  331. * Instead, users interested in querying GIDs should refer to path record
  332. * of the rdma_cm_id to query the GIDs.
  333. * This API is provided for compatibility for existing users.
  334. */
  335. void rdma_read_gids(struct rdma_cm_id *cm_id, union ib_gid *sgid,
  336. union ib_gid *dgid);
  337. struct iw_cm_id *rdma_iw_cm_id(struct rdma_cm_id *cm_id);
  338. struct rdma_cm_id *rdma_res_to_id(struct rdma_restrack_entry *res);
  339. #endif /* RDMA_CM_H */