[DAPL2] DAPL Counters & 2.0.3 extensions to support counter retrieval.
[mirror/winof/.git] / ulp / dapl2 / dat / include / dat / dat_ib_extensions.h
1 /*\r
2  * Copyright (c) 2007 Intel Corporation.  All rights reserved.\r
3  * \r
4  * This Software is licensed under one of the following licenses:\r
5  * \r
6  * 1) under the terms of the "Common Public License 1.0" a copy of which is\r
7  *    in the file LICENSE.txt in the root directory. The license is also\r
8  *    available from the Open Source Initiative, see \r
9  *    http://www.opensource.org/licenses/cpl.php.\r
10  * \r
11  * 2) under the terms of the "The BSD License" a copy of which is in the file\r
12  *    LICENSE2.txt in the root directory. The license is also available from\r
13  *    the Open Source Initiative, see\r
14  *    http://www.opensource.org/licenses/bsd-license.php.\r
15  * \r
16  * 3) under the terms of the "GNU General Public License (GPL) Version 2" a\r
17  *    copy of which is in the file LICENSE3.txt in the root directory. The\r
18  *    license is also available from the Open Source Initiative, see\r
19  *    http://www.opensource.org/licenses/gpl-license.php.\r
20  * \r
21  * Licensee has the right to choose one of the above licenses.\r
22  * \r
23  * Redistributions of source code must retain the above copyright\r
24  * notice and one of the license notices.\r
25  * \r
26  * Redistributions in binary form must reproduce both the above copyright\r
27  * notice, one of the license notices in the documentation\r
28  * and/or other materials provided with the distribution.\r
29  */\r
30 \r
31 /**********************************************************************\r
32  *\r
33  * HEADER: dat_ib_extensions.h\r
34  *\r
35  * PURPOSE: extensions to the DAT API for IB transport specific services \r
36  *          NOTE: Prototyped IB extension support in openib-cma 1.2 provider.\r
37  *                Applications MUST recompile with new dat.h definitions\r
38  *                and include this file.\r
39  *\r
40  * Description: Header file for "uDAPL: User Direct Access Programming\r
41  *              Library, Version: 2.0"\r
42  *\r
43  * Mapping rules:\r
44  *      All global symbols are prepended with "DAT_" or "dat_"\r
45  *      All DAT objects have an 'api' tag which, such as 'ep' or 'lmr'\r
46  *      The method table is in the provider definition structure.\r
47  *\r
48  *\r
49  **********************************************************************/\r
50 #ifndef _DAT_IB_EXTENSIONS_H_\r
51 #define _DAT_IB_EXTENSIONS_H_\r
52 \r
53 /* \r
54  * Provider specific attribute strings for extension support \r
55  *      returned with dat_ia_query() and \r
56  *      DAT_PROVIDER_ATTR_MASK == DAT_PROVIDER_FIELD_PROVIDER_SPECIFIC_ATTR\r
57  *\r
58  *      DAT_NAMED_ATTR  name == extended operations and version, \r
59  *                      version_value = version number of extension API\r
60  */\r
61  \r
62  /* 2.0.1 - Initial IB extension support, atomic and immed data\r
63   *         dat_ib_post_fetch_and_add()\r
64   *         dat_ib_post_cmp_and_swap()\r
65   *         dat_ib_post_rdma_write_immed()\r
66   *             \r
67   * 2.0.2 - Add UD support, post send and remote_ah via connect events \r
68   *         dat_ib_post_send_ud()\r
69   *\r
70   * 2.0.3 - Add query/print counter support for IA, EP, and EVD's \r
71   *         dat_query_counters(), dat_print_counters()\r
72   *\r
73   */\r
74 #define DAT_IB_EXTENSION_VERSION        203     /* 2.0.3 */\r
75 #define DAT_ATTR_COUNTERS                       "DAT_COUNTERS"\r
76 #define DAT_IB_ATTR_FETCH_AND_ADD       "DAT_IB_FETCH_AND_ADD"\r
77 #define DAT_IB_ATTR_CMP_AND_SWAP        "DAT_IB_CMP_AND_SWAP"\r
78 #define DAT_IB_ATTR_IMMED_DATA          "DAT_IB_IMMED_DATA"\r
79 \r
80 /* \r
81  * Definition for extended EVENT numbers, DAT_IB_EXTENSION_BASE_RANGE\r
82  * is used by these extensions as a starting point for extended event numbers \r
83  */\r
84 typedef enum dat_ib_event_number\r
85 {\r
86         DAT_IB_DTO_EVENT = DAT_IB_EXTENSION_RANGE_BASE,\r
87 \r
88 } DAT_IB_EVENT_NUMBER;\r
89 \r
90 /* \r
91  * Extension operations \r
92  */\r
93 typedef enum dat_ib_op\r
94 {\r
95         DAT_IB_FETCH_AND_ADD_OP,\r
96         DAT_IB_CMP_AND_SWAP_OP,\r
97         DAT_IB_RDMA_WRITE_IMMED_OP,\r
98         DAT_IB_UD_SEND_OP,\r
99         DAT_QUERY_COUNTERS_OP,\r
100         DAT_PRINT_COUNTERS_OP\r
101         \r
102 } DAT_IB_OP;\r
103 \r
104 /*\r
105  * The DAT_IB_EXT_TYPE enum specifies the type of extension operation that just\r
106  * completed. All IB extended completion types both, DTO and NON-DTO, are \r
107  * reported in the extended operation type with the single DAT_IB_DTO_EVENT type. \r
108  * The specific extended DTO operation is reported with a DAT_IB_DTOS type in the \r
109  * operation field of the base DAT_EVENT structure. All other extended events are \r
110  * identified by unique DAT_IB_EVENT_NUMBER types.\r
111  */\r
112 typedef enum dat_ib_ext_type\r
113 {\r
114         DAT_IB_FETCH_AND_ADD,           // 0\r
115         DAT_IB_CMP_AND_SWAP,            // 1\r
116         DAT_IB_RDMA_WRITE_IMMED,        // 2\r
117         DAT_IB_RDMA_WRITE_IMMED_DATA,   // 3\r
118 \r
119 } DAT_IB_EXT_TYPE;\r
120 \r
121 /* \r
122  * Extension event status\r
123  */\r
124 typedef enum dat_ib_status\r
125 {\r
126         DAT_OP_SUCCESS = DAT_SUCCESS,\r
127         DAT_IB_OP_ERR,\r
128 \r
129 } DAT_IB_STATUS;\r
130 \r
131 \r
132 /* \r
133  * Definitions for additional extension type RETURN codes above\r
134  * standard DAT types. Included with standard DAT_TYPE_STATUS \r
135  * bits using a DAT_EXTENSION BASE as a starting point.\r
136  */\r
137 typedef enum dat_ib_return\r
138 {\r
139         DAT_IB_ERR = DAT_EXTENSION_BASE,\r
140 \r
141 } DAT_IB_RETURN;\r
142 \r
143 /* \r
144  * Definition for extended IB DTO operations, DAT_DTO_EXTENSION_BASE\r
145  * is used by DAT extensions as a starting point of extension DTOs \r
146  */\r
147 typedef enum dat_ib_dtos\r
148 {\r
149         DAT_IB_DTO_RDMA_WRITE_IMMED = DAT_DTO_EXTENSION_BASE,\r
150         DAT_IB_DTO_RECV_IMMED,\r
151         DAT_IB_DTO_FETCH_ADD,\r
152         DAT_IB_DTO_CMP_SWAP,\r
153 \r
154 } DAT_IB_DTOS;\r
155 \r
156 /* \r
157  * Definitions for additional extension handle types beyond \r
158  * standard DAT handle. New Bit definitions MUST start at \r
159  * DAT_HANDLE_TYPE_EXTENSION_BASE\r
160  */\r
161 typedef enum dat_ib_handle_type\r
162 {\r
163     DAT_IB_HANDLE_TYPE_EXT = DAT_HANDLE_TYPE_EXTENSION_BASE,\r
164 \r
165 } DAT_IB_HANDLE_TYPE;\r
166 \r
167 /*\r
168  * The DAT_IB_EVD_EXTENSION_FLAGS enum specifies the EVD extension flags that\r
169  * do not map directly to existing DAT_EVD_FLAGS. This new EVD flag has been \r
170  * added to identify an extended EVD that does not fit the existing stream \r
171  * types.\r
172  */\r
173 typedef enum dat_ib_evd_extension_flags\r
174 {\r
175         DAT_IB_EVD_EXTENSION_FLAG = DAT_EVD_EXTENSION_BASE\r
176 \r
177 } DAT_IB_EVD_EXTENSION_FLAGS;\r
178 \r
179 /* \r
180  * Definition for memory privilege extension flags.\r
181  * New privileges required for new atomic DTO type extensions.\r
182  * New Bit definitions MUST start at DAT_MEM_PRIV_EXTENSION\r
183  */\r
184 typedef enum dat_ib_mem_priv_flags\r
185 {\r
186         DAT_IB_MEM_PRIV_REMOTE_ATOMIC = DAT_MEM_PRIV_EXTENSION_BASE,\r
187         \r
188 } DAT_IB_MEM_PRIV_FLAGS;\r
189 \r
190 /*\r
191  * Definitions for 64-bit IA Counters\r
192  */\r
193 typedef enum dat_ia_counters\r
194 {\r
195         DCNT_IA_PZ_CREATE,\r
196         DCNT_IA_PZ_FREE,\r
197         DCNT_IA_LMR_CREATE,\r
198         DCNT_IA_LMR_FREE,\r
199         DCNT_IA_RMR_CREATE,\r
200         DCNT_IA_RMR_FREE,\r
201         DCNT_IA_PSP_CREATE,\r
202         DCNT_IA_PSP_CREATE_ANY,\r
203         DCNT_IA_PSP_FREE,\r
204         DCNT_IA_RSP_CREATE,\r
205         DCNT_IA_RSP_FREE,\r
206         DCNT_IA_EVD_CREATE,\r
207         DCNT_IA_EVD_FREE,\r
208         DCNT_IA_EP_CREATE,\r
209         DCNT_IA_EP_FREE,\r
210         DCNT_IA_SRQ_CREATE,\r
211         DCNT_IA_SRQ_FREE,\r
212         DCNT_IA_SP_CR,\r
213         DCNT_IA_SP_CR_ACCEPTED,\r
214         DCNT_IA_SP_CR_REJECTED,\r
215         DCNT_IA_MEM_ALLOC,\r
216         DCNT_IA_MEM_ALLOC_DATA,\r
217         DCNT_IA_MEM_FREE,\r
218         DCNT_IA_ASYNC_ERROR,\r
219         DCNT_IA_ASYNC_QP_ERROR,\r
220         DCNT_IA_ASYNC_CQ_ERROR,\r
221         DCNT_IA_ALL_COUNTERS,  /* MUST be last */\r
222 \r
223 } DAT_IA_COUNTERS;\r
224 \r
225 /*\r
226  * Definitions for 64-bit EP Counters\r
227  */\r
228 typedef enum dat_ep_counters\r
229 {\r
230         DCNT_EP_CONNECT,\r
231         DCNT_EP_DISCONNECT,\r
232         DCNT_EP_POST_SEND,\r
233         DCNT_EP_POST_SEND_DATA,\r
234         DCNT_EP_POST_SEND_UD,\r
235         DCNT_EP_POST_SEND_UD_DATA,\r
236         DCNT_EP_POST_RECV,\r
237         DCNT_EP_POST_RECV_DATA,\r
238         DCNT_EP_POST_WRITE,\r
239         DCNT_EP_POST_WRITE_DATA,\r
240         DCNT_EP_POST_WRITE_IMM,\r
241         DCNT_EP_POST_WRITE_IMM_DATA,\r
242         DCNT_EP_POST_READ,\r
243         DCNT_EP_POST_READ_DATA,\r
244         DCNT_EP_POST_CMP_SWAP,\r
245         DCNT_EP_POST_FETCH_ADD,\r
246         DCNT_EP_RECV,\r
247         DCNT_EP_RECV_DATA,\r
248         DCNT_EP_RECV_UD,\r
249         DCNT_EP_RECV_UD_DATA,\r
250         DCNT_EP_RECV_IMM,\r
251         DCNT_EP_RECV_IMM_DATA,\r
252         DCNT_EP_RECV_RDMA_IMM,\r
253         DCNT_EP_RECV_RDMA_IMM_DATA,\r
254         DCNT_EP_ALL_COUNTERS,  /* MUST be last */\r
255 \r
256 } DAT_EP_COUNTERS;\r
257 \r
258 /*\r
259  * Definitions for 64-bit EVD Counters\r
260  */\r
261 typedef enum dat_evd_counters\r
262 {\r
263         DCNT_EVD_WAIT,\r
264         DCNT_EVD_WAIT_BLOCKED,\r
265         DCNT_EVD_WAIT_NOTIFY,\r
266         DCNT_EVD_DEQUEUE,\r
267         DCNT_EVD_DEQUEUE_FOUND,\r
268         DCNT_EVD_DEQUEUE_NOT_FOUND,\r
269         DCNT_EVD_DEQUEUE_POLL,\r
270         DCNT_EVD_DEQUEUE_POLL_FOUND,\r
271         DCNT_EVD_CONN_CALLBACK,\r
272         DCNT_EVD_DTO_CALLBACK,\r
273         DCNT_EVD_ALL_COUNTERS,  /* MUST be last */\r
274 \r
275 } DAT_EVD_COUNTERS;\r
276 \r
277 /* \r
278  * Definitions for extended event data:\r
279  *      When dat_event->event_number >= DAT_IB_EXTENSION_BASE_RANGE\r
280  *      then dat_event->extension_data == DAT_IB_EXT_EVENT_DATA type\r
281  *      and ((DAT_IB_EXT_EVENT_DATA*)dat_event->extension_data)->type\r
282  *      specifies extension data values. \r
283  * NOTE: DAT_IB_EXT_EVENT_DATA cannot exceed 64 bytes as defined by \r
284  *       "DAT_UINT64 extension_data[8]" in DAT_EVENT (dat.h)\r
285  */\r
286 typedef struct dat_ib_immed_data \r
287 {\r
288     DAT_UINT32                  data;\r
289 \r
290 } DAT_IB_IMMED_DATA;\r
291 \r
292 /* \r
293  * Definitions for extended event data:\r
294  *      When dat_event->event_number >= DAT_IB_EXTENSION_BASE_RANGE\r
295  *      then dat_event->extension_data == DAT_EXTENSION_EVENT_DATA type\r
296  *      and ((DAT_EXTENSION_EVENT_DATA*)dat_event->extension_data)->type\r
297  *      specifies extension data values. \r
298  * NOTE: DAT_EXTENSION_EVENT_DATA cannot exceed 64 bytes as defined by \r
299  *       "DAT_UINT64 extension_data[8]" in DAT_EVENT (dat.h)\r
300  */\r
301 typedef struct dat_ib_extension_event_data\r
302 {\r
303     DAT_IB_EXT_TYPE     type;\r
304     DAT_IB_STATUS       status;\r
305     union {\r
306                 DAT_IB_IMMED_DATA       immed;\r
307     } val;\r
308 \r
309 } DAT_IB_EXTENSION_EVENT_DATA;\r
310 \r
311 /* Extended RETURN and EVENT STATUS string helper functions */\r
312 \r
313 /* DAT_EXT_RETURN error to string */\r
314 static __inline__ DAT_RETURN DAT_API\r
315 dat_strerror_extension (\r
316     IN  DAT_IB_RETURN           value,\r
317     OUT const char              **message )\r
318 {\r
319         switch( DAT_GET_TYPE(value) ) {\r
320         case DAT_IB_ERR:\r
321                 *message = "DAT_IB_ERR";\r
322                 return DAT_SUCCESS;\r
323         default:\r
324                 /* standard DAT return type */\r
325                 return(dat_strerror(value, message, NULL));\r
326         }\r
327 }\r
328 \r
329 /* DAT_EXT_STATUS error to string */\r
330 static __inline__ DAT_RETURN DAT_API\r
331 dat_strerror_ext_status (\r
332     IN  DAT_IB_STATUS   value,\r
333     OUT const char      **message )\r
334 {\r
335         switch(value) {\r
336         case 0:\r
337                 *message = " ";\r
338                 return DAT_SUCCESS;\r
339         case DAT_IB_OP_ERR:\r
340                 *message = "DAT_IB_OP_ERR";\r
341                 return DAT_SUCCESS;\r
342         default:\r
343                 *message = "unknown extension status";\r
344                 return DAT_INVALID_PARAMETER;\r
345         }\r
346 }\r
347 \r
348 /* \r
349  * Extended IB transport specific APIs\r
350  *  redirection via DAT extension function\r
351  */\r
352 \r
353 /*\r
354  * This asynchronous call is modeled after the InfiniBand atomic \r
355  * Fetch and Add operation. The add_value is added to the 64 bit \r
356  * value stored at the remote memory location specified in remote_iov\r
357  * and the result is stored in the local_iov.  \r
358  */\r
359 #define dat_ib_post_fetch_and_add(ep, add_val, lbuf, cookie, rbuf, flgs) \\r
360              dat_extension_op(  ep, \\r
361                                 DAT_IB_FETCH_AND_ADD_OP, \\r
362                                 (add_val), \\r
363                                 (lbuf), \\r
364                                 (cookie), \\r
365                                 (rbuf), \\r
366                                 (flgs))\r
367                                 \r
368 /*\r
369  * This asynchronous call is modeled after the InfiniBand atomic \r
370  * Compare and Swap operation. The cmp_value is compared to the 64 bit \r
371  * value stored at the remote memory location specified in remote_iov.  \r
372  * If the two values are equal, the 64 bit swap_value is stored in \r
373  * the remote memory location.  In all cases, the original 64 bit \r
374  * value stored in the remote memory location is copied to the local_iov.\r
375  */\r
376 #define dat_ib_post_cmp_and_swap(ep, cmp_val, swap_val, lbuf, cookie, rbuf, flgs) \\r
377              dat_extension_op(  ep, \\r
378                                 DAT_IB_CMP_AND_SWAP_OP, \\r
379                                 (cmp_val), \\r
380                                 (swap_val), \\r
381                                 (lbuf), \\r
382                                 (cookie), \\r
383                                 (rbuf), \\r
384                                 (flgs))\r
385 \r
386 /* \r
387  * RDMA Write with IMMEDIATE:\r
388  *\r
389  * This asynchronous call is modeled after the InfiniBand rdma write with  \r
390  * immediate data operation. Event completion for the request completes as an \r
391  * DAT_EXTENSION with extension type set to DAT_DTO_EXTENSION_IMMED_DATA.\r
392  * Event completion on the remote endpoint completes as receive DTO operation\r
393  * type of DAT_EXTENSION with operation set to DAT_DTO_EXTENSION_IMMED_DATA.\r
394  * The immediate data will be provided in the extented DTO event data structure.\r
395  *\r
396  * Note to Consumers: the immediate data will consume a receive\r
397  * buffer at the Data Sink. \r
398  *\r
399  * Other extension flags:\r
400  *      n/a\r
401  */\r
402 #define dat_ib_post_rdma_write_immed(ep, size, lbuf, cookie, rbuf, idata, flgs) \\r
403              dat_extension_op(  ep, \\r
404                                 DAT_IB_RDMA_WRITE_IMMED_OP, \\r
405                                 (size), \\r
406                                 (lbuf), \\r
407                                 (cookie), \\r
408                                 (rbuf), \\r
409                                 (idata), \\r
410                                 (flgs))\r
411 \r
412 \r
413 /* \r
414  * Query counter(s):  \r
415  * Provide IA, EP, or EVD and call will return appropriate counters\r
416  *      DAT_HANDLE dat_handle, enum cntr, *DAT_UINT64 p_cntrs_out, int reset\r
417  *\r
418  * use _ALL_COUNTERS to query all\r
419  */\r
420 #define dat_query_counters(dat_handle, cntr, p_cntrs_out, reset) \\r
421              dat_extension_op(  dat_handle, \\r
422                                 DAT_QUERY_COUNTERS_OP, \\r
423                                 (cntr), \\r
424                                 (p_cntrs_out), \\r
425                                 (reset))\r
426 /* \r
427  * Print counter(s):  \r
428  * Provide IA, EP, or EVD and call will print appropriate counters\r
429  *      DAT_HANDLE dat_handle, int cntr, int reset\r
430  * \r
431  * use _ALL_COUNTERS to print all\r
432  */\r
433 #define dat_print_counters(dat_handle, cntr, reset) \\r
434              dat_extension_op(  dat_handle, \\r
435                                 DAT_PRINT_COUNTERS_OP, \\r
436                                 (cntr), \\r
437                                 (reset))\r
438 \r
439 #endif /* _DAT_IB_EXTENSIONS_H_ */\r
440 \r