[MTHCA\MT23108\IBAL] change to support TRAP and TRAP_REPRESS
[mirror/winof/.git] / inc / user / iba / ib_uvp.h
1 /*\r
2  * Copyright (c) 2005 SilverStorm Technologies.  All rights reserved.\r
3  * Copyright (c) 1996-2003 Intel Corporation. All rights reserved. \r
4  *\r
5  * This software is available to you under the OpenIB.org BSD license\r
6  * below:\r
7  *\r
8  *     Redistribution and use in source and binary forms, with or\r
9  *     without modification, are permitted provided that the following\r
10  *     conditions are met:\r
11  *\r
12  *      - Redistributions of source code must retain the above\r
13  *        copyright notice, this list of conditions and the following\r
14  *        disclaimer.\r
15  *\r
16  *      - Redistributions in binary form must reproduce the above\r
17  *        copyright notice, this list of conditions and the following\r
18  *        disclaimer in the documentation and/or other materials\r
19  *        provided with the distribution.\r
20  *\r
21  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
22  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
23  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
24  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS\r
25  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\r
26  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
27  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\r
28  * SOFTWARE.\r
29  *\r
30  * $Id$\r
31  */\r
32 \r
33 #ifndef __IB_UAL_UVP_H__\r
34 #define __IB_UAL_UVP_H__\r
35 \r
36 #include <complib/cl_types.h>\r
37 #include <iba/ib_types.h>\r
38 #include <iba/ib_ci.h>\r
39 \r
40 /****h* UAL_UVP_Interface/Overview user-mode Verbs\r
41 * NAME\r
42 *       User-mode Verbs -- User-mode Verbs implements the HCA specific\r
43 *       user-mode functions to plug in to the Usermode Access Layer\r
44 *       Architecture (UAL)\r
45 *\r
46 * COPYRIGHT\r
47 *       Copyright© 2001 Intel Corporation - All Rights Reserved.\r
48 * DESCRIPTION\r
49 *       The user-mode Verbs Interface defines the mechanism for a HCA vendor\r
50 *       to plug into the User-mode Access Layer (UAL) architecture.\r
51 *       Access Layer API is what is exposed to the user-mode applications.\r
52 *       The     interface described here is not Verbs API. In this interface model,\r
53 *       UAL provides a generic mechanism to exchange vendor specific info\r
54 *       in the implementation of verbs within the UAL architecture. UAL provides\r
55 *       the support for callback processing. For instance, AL provides a\r
56 *       QP error callback when a qp incurs error. Such asynchronous events are\r
57 *       handled with the support of UAL and not by the vendor interface described\r
58 *       here.\r
59 *\r
60 *       For verbs related AL APIs, UAL packages the parameters in an IOCTL\r
61 *       and sends it to the kernel AL. In the UAL design, this is broken down\r
62 *       into 3 steps.\r
63 *\r
64 *       a. Pre-ioctl step\r
65 *               A vendor specified pre-ioctl function is called with relevant input\r
66 *               parameters including a private buffer template (ci_umv_buf_t)\r
67 *               for the vendor to communicate with the corresponding HCA driver.\r
68 *               For calls that does not go to the HCA driver (for e.g. ib_open_ca())\r
69 *               no private buffer will be passed.\r
70 *       b. Sending IOCTL to kernel AL\r
71 *               Following step (a), UAL prepares an IOCTL with the relevant parameters\r
72 *               including the vendor's private buffer. UAL/user-mode proxy does not\r
73 *               interpret the contents of the private buffer.\r
74 *               UAL sends the IOCTL to the user-mode proxy in kernel. The proxy\r
75 *               interfaces with kernel AL to act on behalf the user. AL passes the\r
76 *               parameters to the Verbs Provider Driver and the results are returned\r
77 *               back to UAL.\r
78 *       c. Post-ioctl step.\r
79 *               Following the return from IOCTL in step (b), UAL calls a\r
80 *               vendor-specified post-ioctl function with relevant parameters.\r
81 *               UAL will call the post-ioctl function whether or not step (b)\r
82 *               succeeded. The ioctl itself could have successfully returned but\r
83 *               a vendor-specific status in ci_umv_buf_t may indicate a failure.\r
84 *               UAL also passes the ioctl status to the vendor library so that\r
85 *               the appropriate action can be taken in the post call.\r
86 *\r
87 *       Use of ci_umv_buf_t and pre/post return values\r
88 *\r
89 *               1. ci_umv_buf is provided by UAL as a unique buffer template for\r
90 *               a given verbs call. Vendor could keep any info relevant to\r
91 *               the specific verbs call in this buffer. This buffer is sufficient\r
92 *               for uniquely identifying which call it is intended for. For instance,\r
93 *               the umv buffer set up by vendor in a uvp_pre_create_qp() could later\r
94 *               tell the uvp_post_create_qp_t() which QP it is intended for.\r
95 *\r
96 *               2. The success of pre/post-ioctl step to UAL means IB_SUCCESS.\r
97 *               Any value other than IB_SUCCESS is treated as failure.\r
98 *\r
99 *               3. The Vendor could exchange a status in ci_umv_buf_t. However, this\r
100 *               interface does not enumerate the status in ci_umv_buf_t.\r
101 *               However, the vendor could check the status in ci_umv_buf_t\r
102 *               returned from the pre-ioctl     step and act accordingly.\r
103 *\r
104 * AUTHOR\r
105 *       Intel Corporation\r
106 * CREATION DATE\r
107 *       XX.XX.XX\r
108 * NOTES\r
109 *       1. For user mode verbs that require a kernel transition, handles passed\r
110 *       to kernel are validated in the  user-mode proxy running in kernel.\r
111 *       Those Verbs that are entirely done in user mode that would affect\r
112 *       speed path do not perform consistency checks. So invalid pointers\r
113 *       would lead to application crash with core dumps.\r
114 *\r
115 *******\r
116 *\r
117 */\r
118 \r
119 /******/\r
120 \r
121 /******/\r
122 \r
123 /*\r
124 *\r
125 *       Vendor-specific handles\r
126 *\r
127 */\r
128 \r
129 /****f* user-mode Verbs/unsupported functions\r
130 * NAME\r
131 *       1. Register physical memory region with HCA (ci_register_pmr)\r
132 *       2. Modify physical memory region with HCA (ci_modify_pmr)\r
133 *       3. Create Special QP    (ci_create_spl_qp)\r
134 *\r
135 *       For all these functions, the vendor does NOT provide support\r
136 *       and UAL will return IB_UNSUPPORTED to the caller of Access Layer.\r
137 *\r
138 * SYNOPSIS\r
139 */\r
140 \r
141 /********/\r
142 \r
143 /****f* user-mode Verbs/uvp_pre_open_ca_t\r
144 * NAME\r
145 *       uvp_pre_open_ca_t -- Pre-ioctl operation for user-mode ib_open_ca()\r
146 *\r
147 * SYNOPSIS\r
148 */\r
149 \r
150 typedef ib_api_status_t\r
151 (AL_API *uvp_pre_open_ca_t) (\r
152         IN              const   ib_net64_t                                      ca_guid,\r
153         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
154 \r
155 /*\r
156 * DESCRIPTION\r
157 *       uvp_pre_open_ca_t() is implemented by vendor. It is the pre-ioctl routine\r
158 *       for the AL call ib_open_ca() in user-mode.\r
159 *\r
160 *\r
161 * PARAMETERS\r
162 *       ca_guid\r
163 *               [in] The HCA adapter's EUI64 identifier. Clients would use other\r
164 *               enumeration API's to locate all available adapters and their\r
165 *               guids in a system, e.g. GetCaGuids(), maintained by the IB\r
166 *               Access Layer.\r
167 *\r
168 *       p_umv_buf\r
169 *               [in out] On input, UAL provides this buffer template.\r
170 *               On return from this function, p_umv_buf contains any vendor-specific\r
171 *               record to be exchanged with the vendor's HCA driver.\r
172 *\r
173 * RETURN VALUE\r
174 *       IB_SUCCESS\r
175 *               The pre-ioctl function succeeded.\r
176 *       IB_INSUFFICIENT_RESOURCES\r
177 *               Insufficient resources to satisfy request.\r
178 *       IB_INVALID_PARAMETER\r
179 *               Invalid GUID.\r
180 *\r
181 * PORTABILITY\r
182 *       User Mode\r
183 *\r
184 * SEE ALSO\r
185 *       uvp_post_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t, uvp_pre_modify_ca,\r
186 *       uvp_post_modify_ca_t,   uvp_pre_close_ca_t, uvp_post_close_ca_t\r
187 *\r
188 *********/\r
189 \r
190 /********/\r
191 \r
192 /****f* user-mode Verbs/uvp_post_open_ca_t\r
193 * NAME\r
194 *       uvp_post_open_ca_t -- Post-ioctl operation for user-mode ib_open_ca()\r
195 *\r
196 * SYNOPSIS\r
197 */\r
198 \r
199 typedef ib_api_status_t\r
200 (AL_API *uvp_post_open_ca_t) (\r
201         IN              const   ib_net64_t                                      ca_guid,\r
202         IN                              ib_api_status_t                         ioctl_status,\r
203                 OUT                     ib_ca_handle_t                          *ph_uvp_ca,\r
204         IN                              ci_umv_buf_t                            *p_umv_buf );\r
205 /*\r
206 * DESCRIPTION\r
207 *       uvp_post_open_ca_t() is implemented by vendor. It is the post-ioctl routine\r
208 *       for the AL call ib_open_ca() in user-mode.\r
209 *\r
210 * PARAMETERS\r
211 *       ca_guid\r
212 *               [in] The HCA adapter's EUI64 identifier.\r
213 *       ioctl_status\r
214 *               [in] The ioctl status of the AL API.\r
215 *       ph_uvp_ca\r
216 *               [out] Pointer to vendor's handle to the newly opened instance of\r
217 *               the CA.\r
218 *       p_umv_buf\r
219 *               [in] This contains any vendor-specific private information\r
220 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_open_ca).\r
221 *               Vendor is expected to check vendor-specific status in\r
222 *               umv_buf as appropriate.\r
223 *\r
224 * RETURN VALUE\r
225 *       IB_SUCCESS\r
226 *               The HCA is return handle is valid.\r
227 *       IB_INSUFFICIENT_RESOURCES\r
228 *               Insufficient resources to satisfy request.\r
229 *\r
230 * PORTABILITY\r
231 *       User Mode\r
232 *\r
233 * SEE ALSO\r
234 *       uvp_pre_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t, uvp_pre_modify_ca,\r
235 *       uvp_post_modify_ca_t,   uvp_pre_close_ca_t, uvp_post_close_ca_t\r
236 *\r
237 *********/\r
238 \r
239 /********/\r
240 \r
241 /****f* user-mode Verbs/uvp_pre_query_ca\r
242 * NAME\r
243 *       uvp_pre_query_ca -- Pre-ioctl operation for user-mode ib_query_ca()\r
244 *\r
245 * SYNOPSIS\r
246 */\r
247 typedef ib_api_status_t\r
248 (AL_API *uvp_pre_query_ca) (\r
249         IN                              ib_ca_handle_t                          h_uvp_ca,\r
250         IN                              ib_ca_attr_t                            *p_ca_attr,\r
251         IN                              size_t                                          byte_count,\r
252         IN                              ci_umv_buf_t                            *p_umv_buf );\r
253 /*\r
254 * DESCRIPTION\r
255 *       uvp_pre_query_ca() is implemented by vendor. It is the pre-ioctl routine\r
256 *       for the AL call ib_query_ca() in user-mode.\r
257 *\r
258 * PARAMETERS\r
259 *       h_uvp_ca\r
260 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
261 *       p_ca_attr\r
262 *               [in] Pointer to the user's CA attribute buffer.\r
263 *       byte_count\r
264 *               [in] User-supplied size of the CA attribute buffer.\r
265 *       p_umv_buf\r
266 *               [in out] On input, UAL provides this buffer template.\r
267 *               On return from this function, p_umv_buf contains any vendor-specific\r
268 *               record to be exchanged with the vendor's HCA driver.\r
269 *\r
270 * RETURN VALUE\r
271 *       IB_SUCCESS\r
272 *               The pre-ioctl function succeeded.\r
273 *       IB_INVALID_CA_HANDLE\r
274 *               CA handle is invalid\r
275 *       IB_INSUFFICIENT_RESOURCES\r
276 *               Insufficient resources to satisfy request.\r
277 *\r
278 * PORTABILITY\r
279 *       User Mode\r
280 *\r
281 * SEE ALSO\r
282 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_post_query_ca_t, uvp_pre_modify_ca,\r
283 *       uvp_post_modify_ca_t,   uvp_pre_close_ca_t, uvp_post_close_ca_t\r
284 *\r
285 *********/\r
286 \r
287 /********/\r
288 \r
289 /****f* user-mode Verbs/uvp_post_query_ca_t\r
290 * NAME\r
291 *       uvp_post_query_ca_t -- Post-ioctl operation for user-mode ib_query_ca()\r
292 *\r
293 * SYNOPSIS\r
294 */\r
295 \r
296 typedef void\r
297 (AL_API *uvp_post_query_ca_t) (\r
298         IN                              ib_ca_handle_t                          h_uvp_ca,\r
299         IN                              ib_api_status_t                         ioctl_status,\r
300         IN                              ib_ca_attr_t                            *p_ca_attr,\r
301         IN                              size_t                                          byte_count,\r
302         IN                              ci_umv_buf_t                            *p_umv_buf );\r
303 /*\r
304 * DESCRIPTION\r
305 *       uvp_post_query_ca_t() is implemented by vendor. It is the post-ioctl routine\r
306 *       for the AL call ib_query_ca() in user-mode. UAL provides the results\r
307 *       of querying the CA attributes to the vendor's post-ioctl routine.\r
308 *\r
309 * PARAMETERS\r
310 *       h_uvp_ca\r
311 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
312 *       ioctl_status\r
313 *               [in] The ioctl status of the AL API.\r
314 *       p_ca_attr\r
315 *               [in] CA attribute of this Host Channel adapter (as returned by\r
316 *               from ioctl to kernel AL).\r
317 *       byte_count\r
318 *               [in] Number of bytes in ca_attr buffer.\r
319 *       p_umv_buf\r
320 *               [in ] This contains any vendor-specific private information\r
321 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_query_ca).\r
322 *               Vendor is expected to check vendor-specific status in\r
323 *               umv_buf as appropriate.\r
324 *\r
325 * RETURN VALUE\r
326 *       This function does not return a value.\r
327 *\r
328 * PORTABILITY\r
329 *       User Mode\r
330 *\r
331 * SEE ALSO\r
332 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_pre_query_ca, uvp_pre_modify_ca,\r
333 *       uvp_post_modify_ca_t,   uvp_pre_close_ca_t, uvp_post_close_ca_t\r
334 *\r
335 *********/\r
336 \r
337 /********/\r
338 \r
339 /****f* user-mode Verbs/uvp_pre_modify_ca\r
340 * NAME\r
341 *       uvp_pre_modify_ca -- Pre-ioctl operation for user-mode ib_modify_ca()\r
342 *\r
343 * SYNOPSIS\r
344 */\r
345 \r
346 typedef ib_api_status_t\r
347 (AL_API *uvp_pre_modify_ca) (\r
348         IN                              ib_ca_handle_t                          h_uvp_ca,\r
349         IN                              uint8_t                                         port_num,\r
350         IN                              ib_ca_mod_t                                     ca_mod,\r
351         IN              const   ib_port_attr_mod_t* const       p_port_attr_mod );\r
352 \r
353 /*\r
354 * DESCRIPTION\r
355 *       uvp_pre_modify_ca() is implemented by vendor. It is the pre-ioctl routine\r
356 *       for the AL call ib_modify_ca() in user-mode.\r
357 *\r
358 * PARAMETERS\r
359 *       h_uvp_ca\r
360 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
361 *       port_num\r
362 *               [in] An index to the port that is being modified.  The port_num matches\r
363 *               the index of the port as returned through the ib_query_ca call.\r
364 *       ca_mod\r
365 *               [in] A mask of the attributes and counters to modify.\r
366 *       p_port_attr_mod\r
367 *               [in] A list of the specific port attribute information to modify.  For\r
368 *               the access layer to modify an attribute, its corresponding bit must be\r
369 *               set in the ca_mod parameter.\r
370 *\r
371 * RETURN VALUE\r
372 *       IB_SUCCESS\r
373 *               The pre-ioctl function succeeded.\r
374 *       IB_INVALID_CA_HANDLE\r
375 *               CA handle is invalid.\r
376 *       IB_INVALID_PARAMETER\r
377 *               One or more parameters is invalid.\r
378 *\r
379 * PORTABILITY\r
380 *       User Mode\r
381 *\r
382 * SEE ALSO\r
383 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t,\r
384 *       uvp_post_modify_ca_t,   uvp_pre_close_ca_t, uvp_post_close_ca_t\r
385 *\r
386 *********/\r
387 \r
388 /********/\r
389 \r
390 /****f* user-mode Verbs/uvp_post_modify_ca_t\r
391 * NAME\r
392 *       uvp_post_modify_ca_t -- Post-ioctl operation for user-mode ib_modify_ca()\r
393 *\r
394 * SYNOPSIS\r
395 */\r
396 \r
397 typedef void\r
398 (AL_API *uvp_post_modify_ca_t) (\r
399         IN                              ib_ca_handle_t                          h_uvp_ca,\r
400         IN                              ib_api_status_t                         ioctl_status );\r
401 \r
402 /*\r
403 * DESCRIPTION\r
404 *       uvp_post_modify_ca_t() is implemented by vendor. It is the post-ioctl routine\r
405 *       for the AL call ib_modify_ca() in user-mode.\r
406 *\r
407 * PARAMETERS\r
408 *       h_uvp_ca\r
409 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
410 *       ioctl_status\r
411 *               [in] The ioctl status of the AL API.\r
412 *\r
413 * RETURN VALUE\r
414 *       This function does not return a value.\r
415 *\r
416 * PORTABILITY\r
417 *       User Mode\r
418 *\r
419 * SEE ALSO\r
420 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t,\r
421 *       uvp_pre_modify_ca,      uvp_pre_close_ca_t, uvp_post_close_ca_t\r
422 *\r
423 *********/\r
424 \r
425 /********/\r
426 \r
427 /****f* user-mode Verbs/uvp_pre_close_ca_t\r
428 * NAME\r
429 *       uvp_pre_close_ca_t -- Pre-ioctl operation for user-mode ib_close_ca().\r
430 *\r
431 * SYNOPSIS\r
432 */\r
433 \r
434 typedef ib_api_status_t\r
435 (AL_API *uvp_pre_close_ca_t) (\r
436         IN                              ib_ca_handle_t                          h_uvp_ca );\r
437 \r
438 /*\r
439 * DESCRIPTION\r
440 *       uvp_pre_close_ca_t() is implemented by vendor. It is the pre-ioctl routine\r
441 *       for the AL call ib_close_ca() in user-mode.\r
442 *\r
443 * PARAMETERS\r
444 *       h_uvp_ca\r
445 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
446 *\r
447 * RETURN VALUE\r
448 *       IB_SUCCESS\r
449 *               Successfully completed the pre-ioctl.\r
450 *\r
451 * PORTABILITY\r
452 *       User Mode\r
453 *\r
454 * SEE ALSO\r
455 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t,\r
456 *       uvp_pre_modify_ca,      uvp_post_modify_ca_t, uvp_post_close_ca_t\r
457 *\r
458 *********/\r
459 \r
460 /********/\r
461 \r
462 /****f* user-mode Verbs/uvp_post_close_ca_t\r
463 * NAME\r
464 *       uvp_post_close_ca_t -- Post-ioctl operation for user-mode ib_close_ca().\r
465 *\r
466 * SYNOPSIS\r
467 */\r
468 \r
469 typedef ib_api_status_t\r
470 (AL_API *uvp_post_close_ca_t) (\r
471         IN                              ib_ca_handle_t                          h_uvp_ca,\r
472         IN                              ib_api_status_t                         ioctl_status );\r
473 \r
474 /*\r
475 * DESCRIPTION\r
476 *       uvp_post_close_ca_t() is implemented by vendor. It is the post-ioctl routine\r
477 *       for the AL call ib_close_ca().\r
478 *       UAL calls this function in the context of the asynchronous callback\r
479 *       from AL notifying the successful destruction of CA.\r
480 *\r
481 * PARAMETERS\r
482 *       h_uvp_ca\r
483 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
484 *\r
485 * RETURN VALUE\r
486 *       IB_SUCCESS\r
487 *               The post-ioctl for ib_close_ca() successfully completed.\r
488 *\r
489 * PORTABILITY\r
490 *       User Mode\r
491 *\r
492 * SEE ALSO\r
493 *       uvp_pre_open_ca_t, uvp_post_open_ca_t, uvp_pre_query_ca, uvp_post_query_ca_t,\r
494 *       uvp_pre_modify_ca,      uvp_post_modify_ca_t, uvp_pre_close_ca_t\r
495 *\r
496 *********/\r
497 \r
498 /********/\r
499 \r
500 /****f* user-mode Verbs/uvp_pre_ci_call\r
501 * NAME\r
502 *       uvp_pre_ci_call -- Pre-ioctl function to ib_ci_call\r
503 *\r
504 * SYNOPSIS\r
505 */\r
506 \r
507 typedef ib_api_status_t\r
508 (AL_API *uvp_pre_ci_call) (\r
509         IN              const   ib_ca_handle_t                          h_uvp_ca,\r
510         IN              const   void* __ptr64 *         const   handle_array    OPTIONAL,\r
511         IN                              uint32_t                                        num_handles,\r
512         IN                              ib_ci_op_t*                     const   p_ci_op,\r
513         IN      OUT                     ci_umv_buf_t                            *p_umv_buf);\r
514 /*\r
515 * DESCRIPTION\r
516 *       uvp_pre_ci_call() is implemented by vendor. It is the pre-ioctl\r
517 *       routine for ib_ci_call().\r
518 *\r
519 * PARAMETERS\r
520 *       h_uvp_ca\r
521 *               [in] Vendor's user-mode library handle to the CA\r
522 *       handle_array\r
523 *               [in] An array of uvp handles.  For valid types, refer to ib_ci.h or\r
524 *               ib_al.h.  This is an optional parameter.\r
525 *       num_handles\r
526 *               [in] The number of handles in the array.\r
527 *       p_ci_op\r
528 *               [in] The operation that is requested by the client.  For more info,\r
529 *               refer ib_types.h\r
530 *       p_umv_buf\r
531 *               [in out] On input, UAL provides this buffer template.\r
532 *               On return from this function, p_umv_buf contains\r
533 *               any vendor-specific record to be exchanged with the vendor's\r
534 *               HCA driver.\r
535 *\r
536 * RETURN VALUE\r
537 *       IB_SUCCESS\r
538 *               The pre-ioctl is successful.\r
539 *       IB_INSUFFICIENT_RESOURCES\r
540 *               Insufficient resources in Vendor library to complete the call\r
541 *\r
542 * PORTABILITY\r
543 *       User Mode\r
544 *\r
545 * SEE ALSO\r
546 *       uvp_post_ci_call\r
547 *\r
548 ********/\r
549 \r
550 /********/\r
551 \r
552 /****f* user-mode Verbs/uvp_post_ci_call\r
553 * NAME\r
554 *       uvp_post_ci_call -- Post-ioctl function to ib_ci_call\r
555 *\r
556 * SYNOPSIS\r
557 */\r
558 \r
559 typedef void\r
560 (AL_API *uvp_post_ci_call) (\r
561         IN              const   ib_ca_handle_t                          h_uvp_ca,\r
562         IN                              ib_api_status_t                         ioctl_status,\r
563         IN              const   void* __ptr64 *         const   handle_array    OPTIONAL,\r
564         IN                              uint32_t                                        num_handles,\r
565         IN                              ib_ci_op_t*                     const   p_ci_op,\r
566         IN      OUT                     ci_umv_buf_t                            *p_umv_buf);\r
567 /*\r
568 * DESCRIPTION\r
569 *       uvp_post_ci_call() is implemented by vendor. It is the pre-ioctl\r
570 *       routine for ib_ci_call().\r
571 *\r
572 * PARAMETERS\r
573 *       h_uvp_ca\r
574 *               [in] Vendor's user-mode library handle to the CA\r
575 *       ioctl_status\r
576 *               [in] The ioctl status of the AL API.\r
577 *       handle_array\r
578 *               [in] An array of uvp handles.  For valid types, refer to ib_ci.h or\r
579 *               ib_al.h.  This is an optional parameter.\r
580 *       num_handles\r
581 *               [in] The number of handles in the array.\r
582 *       p_ci_op\r
583 *               [in] The operation that is requested by the client.  For more info,\r
584 *               refer ib_types.h\r
585 *       p_umv_buf\r
586 *               [in out] On input, UAL provides this buffer template.\r
587 *               On return from this function, p_umv_buf contains\r
588 *               any vendor-specific record to be exchanged with the vendor's\r
589 *               HCA driver.\r
590 *\r
591 * RETURN VALUE\r
592 *       This function does not return a value.\r
593 *\r
594 * PORTABILITY\r
595 *       User Mode\r
596 *\r
597 * SEE ALSO\r
598 *       uvp_pre_ci_call\r
599 *\r
600 ********/\r
601 \r
602 \r
603 /********/\r
604 \r
605 /****f* user-mode Verbs/uvp_pre_allocate_pd\r
606 * NAME\r
607 *       uvp_pre_allocate_pd -- Pre-ioctl function to allocate PD\r
608 *\r
609 * SYNOPSIS\r
610 */\r
611 \r
612 typedef ib_api_status_t\r
613 (AL_API *uvp_pre_allocate_pd) (\r
614         IN                              ib_ca_handle_t                          h_uvp_ca,\r
615         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
616 \r
617 /*\r
618 * DESCRIPTION\r
619 *       uvp_pre_allocate_pd() is implemented by vendor. It is the pre-ioctl routine\r
620 *       for the AL call ib_alloc_pd() in user-mode.\r
621 *\r
622 * PARAMETERS\r
623 *       h_uvp_ca\r
624 *               [in] Vendor's user-mode library handle to the open instance of the CA\r
625 *       p_umv_buf\r
626 *               [in out] On input, UAL provides this buffer template.\r
627 *               On return from this function, p_umv_buf contains\r
628 *               any vendor-specific record to be exchanged with the vendor's\r
629 *               HCA driver.\r
630 *\r
631 * RETURN VALUE\r
632 *       IB_SUCCESS\r
633 *               The pre-ioctl call is successful.\r
634 *       IB_INVALID_CA_HANDLE\r
635 *               CA handle is invalid.\r
636 *       IB_INSUFFICIENT_RESOURCES\r
637 *               Insufficient resources in Vendor library to complete the call\r
638 *\r
639 * PORTABILITY\r
640 *       User Mode\r
641 *\r
642 * SEE ALSO\r
643 *       uvp_post_allocate_pd_t, uvp_pre_deallocate_pd, uvp_post_deallocate_pd_t\r
644 *\r
645 *******/\r
646 \r
647 /********/\r
648 \r
649 /****f* user-mode Verbs/uvp_post_allocate_pd_t\r
650 * NAME\r
651 *       uvp_post_allocate_pd_t -- Post-ioctl function to allocate PD\r
652 *\r
653 * SYNOPSIS\r
654 */\r
655 \r
656 typedef void\r
657 (AL_API *uvp_post_allocate_pd_t) (\r
658         IN                              ib_ca_handle_t                          h_uvp_ca,\r
659         IN                              ib_api_status_t                         ioctl_status,\r
660                 OUT                     ib_pd_handle_t                          *ph_uvp_pd,\r
661         IN                              ci_umv_buf_t                            *p_umv_buf );\r
662 \r
663 /*\r
664 * DESCRIPTION\r
665 *       uvp_post_allocate_pd_t() is implemented by vendor. It is the post-ioctl\r
666 *       routine for the AL call ib_alloc_pd().\r
667 *\r
668 * PARAMETERS\r
669 *       h_uvp_ca\r
670 *               [in] Vendor's user-mode library CA handle.\r
671 *       ioctl_status\r
672 *               [in] The ioctl status of the AL API.\r
673 *       ph_uvp_pd\r
674 *               [out] The vendor library handle to the newly created protection domain.\r
675 *       p_umv_buf\r
676 *               [in] This contains any vendor-specific private information\r
677 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_allocate_pd).\r
678 *               Vendor is expected to check vendor-specific status in\r
679 *               umv_buf as appropriate.\r
680 *\r
681 * RETURN VALUE\r
682 *       This function does not return a value.\r
683 *\r
684 * PORTABILITY\r
685 *       User Mode\r
686 *\r
687 * SEE ALSO\r
688 *       uvp_pre_allocate_pd, uvp_pre_deallocate_pd, uvp_post_deallocate_pd_t\r
689 *\r
690 *******/\r
691 \r
692 /********/\r
693 \r
694 /****f* user-mode Verbs/uvp_pre_deallocate_pd\r
695 * NAME\r
696 *       uvp_pre_deallocate_pd -- Pre-ioctl function to deallocate PD\r
697 *\r
698 * SYNOPSIS\r
699 */\r
700 \r
701 typedef ib_api_status_t\r
702 (AL_API *uvp_pre_deallocate_pd) (\r
703         IN              const   ib_pd_handle_t                          h_uvp_pd );\r
704 \r
705 /*\r
706 * DESCRIPTION\r
707 *       uvp_pre_deallocate_pd() is implemented by vendor. It is the pre-ioctl\r
708 *       routine for the AL call ib_deallocate_pd().\r
709 *\r
710 * PARAMETERS\r
711 *       h_uvp_pd\r
712 *               [in] Vendor's user-mode library PD handle.\r
713 *\r
714 * RETURN VALUE\r
715 *       IB_SUCCESS\r
716 *               The pre-ioctl call is successful.\r
717 *\r
718 * PORTABILITY\r
719 *       User Mode\r
720 *\r
721 * SEE ALSO\r
722 *       uvp_pre_allocate_pd, uvp_post_allocate_pd_t, uvp_post_deallocate_pd_t\r
723 *\r
724 *******/\r
725 \r
726 /********/\r
727 \r
728 /****f* user-mode Verbs/uvp_post_deallocate_pd_t\r
729 * NAME\r
730 *       uvp_post_deallocate_pd_t -- Post-ioctl function to deallocate PD\r
731 *\r
732 * SYNOPSIS\r
733 */\r
734 \r
735 typedef void\r
736 (AL_API *uvp_post_deallocate_pd_t) (\r
737         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
738         IN                              ib_api_status_t                         ioctl_status );\r
739 \r
740 /*\r
741 * DESCRIPTION\r
742 *       uvp_post_deallocate_pd_t() is implemented by the vendor. It is the\r
743 *       post-ioctl routine for the AL call ib_dealloc_pd().\r
744 *\r
745 *       When all the resouces associated with a PD are destroyed,\r
746 *       UAL invokes this post-ioctl routine to deallocate PD. Since the\r
747 *       completion of the resource deallocation (e.g QP/CQ) is asynchronous,\r
748 *       this function is called from a UAL asynchronous callback\r
749 *       processing thread.\r
750 *\r
751 * PARAMETERS\r
752 *       h_uvp_pd\r
753 *               [in] Vendor's user-mode library PD handle.\r
754 *\r
755 * RETURN VALUE\r
756 *       This function does not return a value.\r
757 *\r
758 * PORTABILITY\r
759 *       User Mode\r
760 *\r
761 * SEE ALSO\r
762 *       uvp_pre_allocate_pd, uvp_post_allocate_pd_t, uvp_pre_deallocate_pd\r
763 *\r
764 *******/\r
765 \r
766 /********/\r
767 \r
768 /****f* user-mode Verbs/uvp_pre_create_av\r
769 * NAME\r
770 *       uvp_pre_create_av -- Pre-ioctl function to create AV\r
771 *\r
772 * SYNOPSIS\r
773 */\r
774 \r
775 typedef ib_api_status_t\r
776 (AL_API *uvp_pre_create_av) (\r
777         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
778         IN              const   ib_av_attr_t                            *p_addr_vector,\r
779         IN      OUT                     ci_umv_buf_t                            *p_umv_buf);\r
780 /*\r
781 * DESCRIPTION\r
782 *       uvp_pre_create_av() is implemented by vendor. It is the pre-ioctl\r
783 *       routine for ib_create_av().\r
784 *\r
785 * PARAMETERS\r
786 *       h_uvp_pd\r
787 *               [in] Vendor's user-mode library handle to the Protection domain\r
788 *               to which this AV is associated.\r
789 *       p_addr_vector\r
790 *               [in] Parameters to create the address vector.\r
791 *       p_umv_buf\r
792 *               [in out] On input, UAL provides this buffer template.\r
793 *               On return from this function, p_umv_buf contains\r
794 *               any vendor-specific record to be exchanged with the vendor's\r
795 *               HCA driver.\r
796 *\r
797 * RETURN VALUE\r
798 *       IB_SUCCESS\r
799 *               The pre-ioctl is successful.\r
800 *       IB_INVALID_SETTING\r
801 *               Values in the vector is not valid\r
802 *       IB_INVALID_PD_HANDLE\r
803 *               The PD handle is invalid.\r
804 *       IB_INSUFFICIENT_RESOURCES\r
805 *               Insufficient resources in Vendor library to complete the call\r
806 *\r
807 * PORTABILITY\r
808 *       User Mode\r
809 *\r
810 * SEE ALSO\r
811 *       uvp_post_create_av_t, uvp_pre_query_av, uvp_post_query_av_t, uvp_pre_modify_av,\r
812 *       uvp_post_modify_av_t, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
813 *\r
814 ********/\r
815 \r
816 /********/\r
817 \r
818 /****f* user-mode Verbs/uvp_post_create_av_t\r
819 * NAME\r
820 *       uvp_post_create_av_t -- Post-ioctl function to create AV\r
821 *\r
822 * SYNOPSIS\r
823 */\r
824 \r
825 typedef void\r
826 (AL_API *uvp_post_create_av_t) (\r
827         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
828         IN                              ib_api_status_t                         ioctl_status,\r
829                 OUT                     ib_av_handle_t                          *ph_uvp_av,\r
830         IN                              ci_umv_buf_t                            *p_umv_buf );\r
831 /*\r
832 * DESCRIPTION\r
833 *       uvp_post_create_av_t() is implemented by vendor. It is the post-ioctl routine\r
834 *       for ib_create_av().\r
835 *\r
836 * PARAMETERS\r
837 *       h_uvp_pd\r
838 *               [in] Vendor's user-mode library handle to the Protection domain\r
839 *               to which this AV is associated\r
840 *       ioctl_status\r
841 *               [in] The ioctl status of the AL API.\r
842 *       ph_uvp_av\r
843 *               [out] Vendor's address vector handle.\r
844 *       p_umv_buf\r
845 *               [in] On input, it contains any vendor-specific private information\r
846 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_create_av).\r
847 *               Vendor is expected to check vendor-specific status in\r
848 *               umv_buf as appropriate.\r
849 *\r
850 * RETURN VALUE\r
851 *       This function does not return a value.\r
852 *\r
853 * PORTABILITY\r
854 *       User Mode\r
855 *\r
856 * SEE ALSO\r
857 *       uvp_pre_create_av, uvp_pre_query_av, uvp_post_query_av_t, uvp_pre_modify_av,\r
858 *       uvp_post_modify_av_t, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
859 *\r
860 ********/\r
861 \r
862 /********/\r
863 \r
864 /****f* user-mode Verbs/uvp_pre_query_av\r
865 * NAME\r
866 *       uvp_pre_query_av -- Pre-ioctl operation for ib_query_ca()\r
867 *\r
868 * SYNOPSIS\r
869 */\r
870 \r
871 typedef ib_api_status_t\r
872 (AL_API *uvp_pre_query_av) (\r
873         IN              const   ib_av_handle_t                          h_uvp_av,\r
874         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
875 \r
876 /*\r
877 * DESCRIPTION\r
878 *       uvp_pre_query_av() is implemented by vendor. It is the pre-ioctl routine\r
879 *       for the AL call ib_query_av() in user-mode.\r
880 *\r
881 * PARAMETERS\r
882 *       h_uvp_av\r
883 *               [in] Vendor's handle to the address vector in user-mode library\r
884 *       p_umv_buf\r
885 *               [in out] On input, UAL provides this buffer template.\r
886 *               On return from this function, p_umv_buf contains\r
887 *               any vendor-specific record to be exchanged with the vendor's\r
888 *               HCA driver.\r
889 *\r
890 * RETURN VALUE\r
891 *       IB_SUCCESS\r
892 *               The pre-ioctl function succeeded.\r
893 *       IB_INVALID_AV_HANDLE\r
894 *               AV handle was invalid\r
895 *       IB_INSUFFICIENT_RESOURCES\r
896 *               Insufficient resources in Vendor library to complete the call.\r
897 *\r
898 * PORTABILITY\r
899 *       User Mode\r
900 *\r
901 * SEE ALSO\r
902 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_post_query_av_t, uvp_pre_modify_av,\r
903 *       uvp_post_modify_av_t, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
904 *\r
905 *********/\r
906 \r
907 /********/\r
908 /****f* user-mode Verbs/uvp_post_query_av_t\r
909 * NAME\r
910 *\r
911 *       Vendor-specific post-ioctl operation for user-mode ib_query_ca()\r
912 * SYNOPSIS\r
913 */\r
914 \r
915 typedef void\r
916 (AL_API *uvp_post_query_av_t) (\r
917         IN              const   ib_av_handle_t                          h_uvp_av,\r
918         IN                              ib_api_status_t                         ioctl_status,\r
919         IN      OUT                     ib_av_attr_t                            *p_addr_vector,\r
920         IN      OUT                     ib_pd_handle_t                          *ph_pd,\r
921         IN                              ci_umv_buf_t                            *p_umv_buf );\r
922 \r
923 /*\r
924 * DESCRIPTION\r
925 *       uvp_post_query_av_t() is implemented by vendor. It is the post-ioctl routine\r
926 *       for the AL call ib_query_av() in user-mode.\r
927 *       UAL provides the results of the query to the vendor library in this\r
928 *       post-ioctl routine.\r
929 *\r
930 * PARAMETERS\r
931 *       h_uvp_av\r
932 *               [in] Vendor's handle to the address vector in user-mode library\r
933 *       ioctl_status\r
934 *               [in] The ioctl status of the AL API.\r
935 *       p_addr_vector\r
936 *               [in out] AV attribute (as returned by the ioctl).\r
937 *       ph_pd\r
938 *               [out] The vendor library PD handle associated with this AV.\r
939 *       p_umv_buf\r
940 *               [in]\r
941 *               On input, it contains any vendor-specific private information\r
942 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_query_av).\r
943 *               Vendor is expected to check vendor-specific status in\r
944 *               umv_buf as appropriate.\r
945 *\r
946 * RETURN VALUE\r
947 *       This function does not return a value.\r
948 *\r
949 * PORTABILITY\r
950 *       User Mode\r
951 *\r
952 * SEE ALSO\r
953 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_pre_query_av, uvp_pre_modify_av,\r
954 *       uvp_post_modify_av_t, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
955 *\r
956 *********/\r
957 \r
958 /********/\r
959 \r
960 /****f* user-mode Verbs/uvp_pre_modify_av\r
961 * NAME\r
962 *       uvp_pre_modify_av -- Pre-ioctl function to modify AV\r
963 *\r
964 * SYNOPSIS\r
965 */\r
966 typedef ib_api_status_t\r
967 (AL_API *uvp_pre_modify_av) (\r
968         IN              const   ib_av_handle_t                          h_uvp_av,\r
969         IN              const   ib_av_attr_t                            *p_addr_vector,\r
970         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
971 /*\r
972 * DESCRIPTION\r
973 *       uvp_pre_modify_av() is implemented by vendor. It is the pre-ioctl routine\r
974 *       for ib_modify_av().\r
975 *\r
976 * PARAMETERS\r
977 *       h_uvp_av\r
978 *               [in] Vendor's AV handle in user-mode library.\r
979 *       p_addr_vector\r
980 *               [in] Parameters to modify the address vector handle\r
981 *       p_umv_buf\r
982 *               [in out] On input, UAL provides this buffer template.\r
983 *               On return from this function, p_umv_buf contains\r
984 *               any vendor-specific record to be exchanged with the vendor's\r
985 *               HCA driver.\r
986 *\r
987 * RETURN VALUE\r
988 *       IB_SUCCESS\r
989 *               The pre-ioctl is successful.\r
990 *       IB_INVALID_SETTING\r
991 *               Values in the vector is not valid.\r
992 *       IB_INVALID_AV_HANDLE\r
993 *               The AV handle is invalid.\r
994 *       IB_INSUFFICIENT_RESOURCES\r
995 *               Insufficient resources in Vendor library to complete the call.\r
996 *\r
997 * PORTABILITY\r
998 *       User Mode\r
999 *\r
1000 * SEE ALSO\r
1001 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_pre_query_av, uvp_post_query_av_t,\r
1002 *       uvp_post_modify_av_t, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
1003 *\r
1004 ********/\r
1005 \r
1006 /********/\r
1007 \r
1008 /****f* user-mode Verbs/uvp_post_modify_av_t\r
1009 * NAME\r
1010 *       uvp_post_modify_av_t -- Post-ioctl function to modify AV\r
1011 * SYNOPSIS\r
1012 */\r
1013 \r
1014 typedef void\r
1015 (AL_API *uvp_post_modify_av_t) (\r
1016         IN              const   ib_av_handle_t                          h_uvp_av,\r
1017         IN                              ib_api_status_t                         ioctl_status,\r
1018         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1019 \r
1020 /*\r
1021 * DESCRIPTION\r
1022 *       uvp_post_modify_av_t() is implemented by vendor to modify the attributes\r
1023 *       of AV. It is the post-ioctl routine for ib_modify_av().\r
1024 *\r
1025 * PARAMETERS\r
1026 *       h_uvp_av\r
1027 *               [in] Vendor's av handle in user-mode library.\r
1028 *       ioctl_status\r
1029 *               [in] The ioctl status of the AL API.\r
1030 *       p_umv_buf\r
1031 *               [in out] On input, it contains any vendor-specific private information\r
1032 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_modify_av).\r
1033 *               Vendor is expected to check vendor-specific status in\r
1034 *               umv_buf as appropriate.\r
1035 *\r
1036 * RETURN VALUE\r
1037 *       This function does not return a value.\r
1038 *\r
1039 * PORTABILITY\r
1040 *       User Mode\r
1041 *\r
1042 * SEE ALSO\r
1043 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_pre_query_av, uvp_post_query_av_t,\r
1044 *       uvp_pre_modify_av, uvp_pre_destroy_av, uvp_post_destroy_av_t\r
1045 *\r
1046 ********/\r
1047 \r
1048 /********/\r
1049 \r
1050 /****f* user-mode Verbs/uvp_pre_destroy_av\r
1051 * NAME\r
1052 *       uvp_pre_destroy_av -- Pre-ioctl function to destroy AV\r
1053 *\r
1054 * SYNOPSIS\r
1055 */\r
1056 \r
1057 typedef ib_api_status_t\r
1058 (AL_API *uvp_pre_destroy_av) (\r
1059         IN              const   ib_av_handle_t                          h_uvp_av );\r
1060 \r
1061 /*\r
1062 * DESCRIPTION\r
1063 *       uvp_pre_destroy_av() is implemented by vendor to destroy the AV.\r
1064 *       It is the pre-ioctl routine for ib_destroy_av().\r
1065 *\r
1066 * PARAMETERS\r
1067 *       h_uvp_av\r
1068 *               [in] Vendor's AV handle in user-mode library.\r
1069 *\r
1070 * RETURN VALUE\r
1071 *       IB_SUCCESS\r
1072 *               The pre-ioctl is successful.\r
1073 *\r
1074 * PORTABILITY\r
1075 *       User Mode\r
1076 *\r
1077 * SEE ALSO\r
1078 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_pre_query_av, uvp_post_query_av_t,\r
1079 *       uvp_pre_modify_av, uvp_post_modify_av_t, uvp_post_destroy_av_t\r
1080 *\r
1081 ********/\r
1082 \r
1083 /********/\r
1084 \r
1085 /****f* user-mode Verbs/uvp_post_destroy_av_t\r
1086 * NAME\r
1087 *       uvp_post_destroy_av_t -- Post-ioctl function to destroy AV\r
1088 *\r
1089 * SYNOPSIS\r
1090 */\r
1091 \r
1092 typedef void\r
1093 (AL_API *uvp_post_destroy_av_t) (\r
1094         IN              const   ib_av_handle_t                          h_uvp_av,\r
1095         IN                              ib_api_status_t                         ioctl_status );\r
1096 \r
1097 /*\r
1098 * DESCRIPTION\r
1099 *       uvp_post_destroy_av_t() is implemented by vendor. It is the post-ioctl\r
1100 *       routine for ib_destroy_av().\r
1101 *\r
1102 * PARAMETERS\r
1103 *       h_uvp_av\r
1104 *               [in] Vendor's AV handle in user-mode library.\r
1105 *       p_umv_buf\r
1106 *               [in out]\r
1107 *               On input, it contains any vendor-specific private information\r
1108 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_destroy_av).\r
1109 *               Vendor is expected to check vendor-specific status in\r
1110 *               umv_buf as appropriate.\r
1111 *\r
1112 * RETURN VALUE\r
1113 *       This function does not return a value.\r
1114 *\r
1115 * PORTABILITY\r
1116 *       User Mode\r
1117 *\r
1118 * SEE ALSO\r
1119 *       uvp_pre_create_av, uvp_post_create_av_t, uvp_pre_query_av, uvp_post_query_av_t,\r
1120 *       uvp_pre_modify_av, uvp_post_modify_av_t, uvp_pre_destroy_av\r
1121 *\r
1122 ********/\r
1123 \r
1124 /********/\r
1125 \r
1126 /****f* user-mode Verbs/uvp_pre_create_qp\r
1127 * NAME\r
1128 *       uvp_pre_create_qp -- Pre-ioctl function to Create a Queue Pair.\r
1129 *\r
1130 * SYNOPSIS\r
1131 */\r
1132 \r
1133 typedef ib_api_status_t\r
1134 (AL_API *uvp_pre_create_qp) (\r
1135         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
1136         IN              const   ib_qp_create_t                          *p_create_attr,\r
1137         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1138 \r
1139 /*\r
1140 * DESCRIPTION\r
1141 *       uvp_pre_create_qp() is implemented by vendor. It is the pre-ioctl routine\r
1142 *       for ib_create_qp().\r
1143 *\r
1144 * PARAMETERS\r
1145 *       h_uvp_pd\r
1146 *               [in] Vendor's Protection domain handle in user-mode library.\r
1147 *       p_create_attr\r
1148 *               [in] Initial attributes with which the qp must be created.\r
1149 *       p_umv_buf\r
1150 *               [in out] On input, UAL provides this buffer template.\r
1151 *               On return from this function, p_umv_buf contains\r
1152 *               any vendor-specific record to be exchanged with the vendor's\r
1153 *               HCA driver.\r
1154 *\r
1155 * RETURN VALUE\r
1156 *       IB_SUCCESS\r
1157 *               The pre-ioctl call is successful.\r
1158 *       IB_INVALID_PD_HANDLE\r
1159 *               The PD handle is invalid.\r
1160 *       IB_INVALID_CQ_HANDLE\r
1161 *               The send or receive completion queue to associate with the queue pair\r
1162 *               is invalid.\r
1163 *       IB_UNSUPPORTED\r
1164 *               The specified queue pair type was not supported by the channel adapter.\r
1165 *       IB_INVALID_MAX_WRS\r
1166 *               The requested maximum send or receive work request depth could not be\r
1167 *               supported.\r
1168 *       IB_INVALID_MAX_SGE\r
1169 *               The requested maximum number of scatter-gather entries for the send or\r
1170 *               receive queue could not be supported.\r
1171 *       IB_INSUFFICIENT_RESOURCES\r
1172 *               Insufficient resources in Vendor library to complete the call.\r
1173 *       IB_INVALID_PARAMETER\r
1174 *               At least one parameter is invalid.\r
1175 *\r
1176 * PORTABILITY\r
1177 *       User Mode\r
1178 *\r
1179 * SEE ALSO\r
1180 *       uvp_post_create_qp_t, uvp_pre_query_qp, uvp_post_query_qp_t, uvp_pre_modify_qp,\r
1181 *       uvp_post_modify_qp_t, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1182 *\r
1183 ********/\r
1184 \r
1185 /********/\r
1186 \r
1187 /****f* user-mode Verbs/uvp_post_create_qp_t\r
1188 * NAME\r
1189 *       uvp_post_create_qp_t -- Post-ioctl function to Create a Queue Pair.\r
1190 *\r
1191 * SYNOPSIS\r
1192 */\r
1193 \r
1194 typedef void\r
1195 (AL_API *uvp_post_create_qp_t) (\r
1196         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
1197         IN                              ib_api_status_t                         ioctl_status,\r
1198                 OUT                     ib_qp_handle_t                          *ph_uvp_qp,\r
1199         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1200 \r
1201 /*\r
1202 * DESCRIPTION\r
1203 *       uvp_post_create_qp_t() is implemented by vendor. It is the post-ioctl routine\r
1204 *       for ib_create_qp().\r
1205 *\r
1206 * PARAMETERS\r
1207 *       h_uvp_pd\r
1208 *               [in] Vendor's Protection domain handle in user-mode library.\r
1209 *       ioctl_status\r
1210 *               [in] The ioctl status of the AL API.\r
1211 *       ph_uvp_qp\r
1212 *               [out] Vendor's QP handle for the newly created QP (in user-mode\r
1213 *               library).\r
1214 *       p_umv_buf\r
1215 *               [in out] On input, it contains any vendor-specific private information\r
1216 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_create_qp).\r
1217 *               Vendor is expected to check vendor-specific status in\r
1218 *               umv_buf as appropriate.\r
1219 *\r
1220 * RETURN VALUE\r
1221 *       This function does not return a value.\r
1222 *\r
1223 * PORTABILITY\r
1224 *       User Mode\r
1225 *\r
1226 * SEE ALSO\r
1227 *       uvp_pre_create_qp, uvp_pre_query_qp, uvp_post_query_qp_t, uvp_pre_modify_qp,\r
1228 *       uvp_post_modify_qp_t, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1229 *\r
1230 ********/\r
1231 \r
1232 /********/\r
1233 \r
1234 /****f* user-mode Verbs/uvp_pre_modify_qp\r
1235 * NAME\r
1236 *       uvp_pre_modify_qp -- Pre-ioctl function to Modify attributes of the\r
1237 *                                                specified QP.\r
1238 *\r
1239 * SYNOPSIS\r
1240 *\r
1241 */\r
1242 \r
1243 typedef ib_api_status_t\r
1244 (AL_API *uvp_pre_modify_qp) (\r
1245         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
1246         IN              const   ib_qp_mod_t                                     *p_modify_attr,\r
1247         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1248 \r
1249 /*\r
1250 * DESCRIPTION\r
1251 *       uvp_pre_modify_qp() is implemented by vendor to modify the attributes of a\r
1252 *       QP. It is the pre-ioctl routine for ib_modify_qp().\r
1253 *\r
1254 * PARAMETERS\r
1255 *       h_uvp_qp\r
1256 *               [in] Vendor's qp Handle to the queue pair (in user-mode library)\r
1257 *               whose state is to be modified.\r
1258 *       p_modify_attr\r
1259 *               [in] Specifies what attributes need to be modified in the qp.\r
1260 *       p_umv_buf\r
1261 *               [in out] On input, UAL provides this buffer template.\r
1262 *               On return from this function, p_umv_buf contains\r
1263 *               any vendor-specific record to be exchanged with the vendor's\r
1264 *               HCA driver.\r
1265 *\r
1266 * RETURN VALUE\r
1267 *       IB_SUCCESS\r
1268 *               The pre-ioctl call is successful.\r
1269 *       IB_INSUFFICIENT_RESOURCES\r
1270 *               Insufficient resources to complete the requested operation.\r
1271 *       IB_INVALID_QP_HANDLE\r
1272 *               Invalid QP handle.\r
1273 *       IB_UNSUPPORTED\r
1274 *               Requested operation is not supported, for e.g. Atomic operations.\r
1275 *       IB_QP_INVALID_STATE\r
1276 *               Invalid state transition request. Current QP state not in allowable\r
1277 *               state.\r
1278 *       IB_INVALID_PKEY\r
1279 *               Pkey specified in modify request not valid entry in P_KEY table. Or\r
1280 *               index is out of range.\r
1281 *       IB_INVALID_PMIG_STATE\r
1282 *               Invalid path migration state specified in the request.\r
1283 *\r
1284 * PORTABILITY\r
1285 *       User mode\r
1286 *\r
1287 * SEE ALSO\r
1288 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_query_qp, uvp_post_query_qp_t,\r
1289 *       uvp_post_modify_qp_t, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1290 *\r
1291 ********/\r
1292 \r
1293 /********/\r
1294 \r
1295 /****f* user-mode Verbs/uvp_post_modify_qp_t\r
1296 * NAME\r
1297 *       uvp_post_modify_qp_t -- Post-ioctl function to Modify attributes of\r
1298 *                                                 the specified QP.\r
1299 *\r
1300 * SYNOPSIS\r
1301 */\r
1302 \r
1303 typedef void\r
1304 (AL_API *uvp_post_modify_qp_t) (\r
1305         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
1306         IN                              ib_api_status_t                         ioctl_status,\r
1307         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1308 \r
1309 /*\r
1310 * DESCRIPTION\r
1311 *       uvp_post_modify_qp_t() is implemented by vendor to modify the qp attributes.\r
1312 *       It is the post-ioctl routine for ib_modify_qp().\r
1313 *\r
1314 * PARAMETERS\r
1315 *       h_uvp_qp\r
1316 *               [in] Vendor's qp Handle to the queue pair (in user-mode library)\r
1317 *               whose state is modified.\r
1318 *       ioctl_status\r
1319 *               [in] The ioctl status of the AL API.\r
1320 *       p_umv_buf\r
1321 *               [in out] On input, it contains any vendor-specific private information\r
1322 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_modify_qp).\r
1323 *               Vendor is expected to check vendor-specific status in\r
1324 *               umv_buf as appropriate.\r
1325 *\r
1326 * RETURN VALUE\r
1327 *       This function does not return a value.\r
1328 *\r
1329 * PORTABILITY\r
1330 *       User mode\r
1331 *\r
1332 * SEE ALSO\r
1333 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_query_qp, uvp_post_query_qp_t,\r
1334 *       uvp_pre_modify_qp, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1335 *\r
1336 ********/\r
1337 \r
1338 /********/\r
1339 \r
1340 /****f* user-mode Verbs/uvp_pre_query_qp\r
1341 * NAME\r
1342 *       uvp_pre_query_qp -- Pre-ioctl function to Query the attributes of the QP\r
1343 *\r
1344 * SYNOPSIS\r
1345 */\r
1346 \r
1347 typedef ib_api_status_t\r
1348 (AL_API *uvp_pre_query_qp) (\r
1349         IN                              ib_qp_handle_t                          h_uvp_qp,\r
1350         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1351 \r
1352 /*\r
1353 * DESCRIPTION\r
1354 *       uvp_pre_query_qp() is implemented by vendor. It is the pre-ioctl routine\r
1355 *       for the AL call ib_query_qp().\r
1356 *\r
1357 * PARAMETERS\r
1358 *       h_uvp_qp\r
1359 *               [in] Vendor's handle to the QP (in user-mode library).\r
1360 *       p_umv_buf\r
1361 *               [in out] On input, UAL provides this buffer template.\r
1362 *               On return from this function, p_umv_buf contains\r
1363 *               any vendor-specific record to be exchanged with the vendor's\r
1364 *               HCA driver.\r
1365 * RETURN VALUE\r
1366 *       IB_SUCCESS\r
1367 *               The pre-ioctl function succeeded.\r
1368 *       IB_INVALID_QP_HANDLE\r
1369 *               QP handle is invalid\r
1370 *       IB_INSUFFICIENT_RESOURCES\r
1371 *               Insufficient resources in Vendor library to complete the call.\r
1372 *\r
1373 * PORTABILITY\r
1374 *       User Mode\r
1375 *\r
1376 * SEE ALSO\r
1377 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_post_query_qp_t, uvp_pre_modify_qp,\r
1378 *       uvp_post_modify_qp_t, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1379 *\r
1380 *********/\r
1381 \r
1382 /********/\r
1383 \r
1384 /****f* user-mode Verbs/uvp_post_query_qp_t\r
1385 * NAME\r
1386 *       uvp_post_query_qp_t -- Post-ioctl operation for user-mode ib_query_qp()\r
1387 *\r
1388 * SYNOPSIS\r
1389 */\r
1390 \r
1391 typedef void\r
1392 (AL_API *uvp_post_query_qp_t) (\r
1393         IN                              ib_qp_handle_t                          h_uvp_qp,\r
1394         IN                              ib_api_status_t                         ioctl_status,\r
1395         IN                              ib_qp_attr_t                            *p_query_attr,\r
1396         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1397 \r
1398 /*\r
1399 * DESCRIPTION\r
1400 *       uvp_post_query_qp_t() is implemented by vendor. It is the post-ioctl routine\r
1401 *       for ib_query_qp().\r
1402 *       UAL provides the results of the query to the vendor library in this\r
1403 *       post-ioctl routine.\r
1404 *\r
1405 * PARAMETERS\r
1406 *       h_uvp_qp\r
1407 *               [in] Vendor's handle to the QP (in user-mode library).\r
1408 *       ioctl_status\r
1409 *               [in] The ioctl status of the AL API.\r
1410 *       p_query_attr\r
1411 *               [in] QP attribute as returned by the ioctl.\r
1412 *       p_umv_buf\r
1413 *               [in out] On input, it contains any vendor-specific private information\r
1414 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_query_qp).\r
1415 *               Vendor is expected to check vendor-specific status in\r
1416 *               umv_buf as appropriate.\r
1417 *\r
1418 * RETURN VALUE\r
1419 *       This function does not return a value.\r
1420 *\r
1421 * PORTABILITY\r
1422 *       User Mode\r
1423 *\r
1424 * SEE ALSO\r
1425 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_query_qp, uvp_pre_modify_qp,\r
1426 *       uvp_post_modify_qp_t, uvp_pre_destroy_qp, uvp_post_destroy_qp_t\r
1427 *\r
1428 *********/\r
1429 \r
1430 /********/\r
1431 \r
1432 /****f* user-mode Verbs/uvp_pre_destroy_qp\r
1433 * NAME\r
1434 *       uvp_pre_destroy_qp -- Pre-ioctl function to Destroy a Queue Pair.\r
1435 * SYNOPSIS\r
1436 */\r
1437 \r
1438 typedef ib_api_status_t\r
1439 (AL_API *uvp_pre_destroy_qp) (\r
1440         IN              const   ib_qp_handle_t                          h_uvp_qp );\r
1441 \r
1442 /*\r
1443 * DESCRIPTION\r
1444 *       uvp_pre_destroy_qp() is the pre-ioctl routine implemented by vendor\r
1445 *       to destroy QP.\r
1446 *       UAL invokes this pre-ioctl routine to destroy QP.\r
1447 *       The vendor is expected to perform any preliminary steps in preparation\r
1448 *       for destroying the QP and perform any book-keeping.\r
1449 *\r
1450 * PARAMETERS\r
1451 *       h_uvp_qp\r
1452 *               [in] Vendor's Handle to the qp (in user-mode library)\r
1453 *               that needs to be destroyed.\r
1454 *       p_umv_buf\r
1455 *               [in out] On input, UAL provides this buffer template.\r
1456 *               On return from this function, p_umv_buf contains\r
1457 *               any vendor-specific record to be exchanged with the vendor's\r
1458 *               HCA driver.\r
1459 *\r
1460 * RETURN VALUE\r
1461 *       IB_SUCCESS\r
1462 *               The pre-ioctl call is successful.\r
1463 *\r
1464 * PORTABILITY\r
1465 *       User mode.\r
1466 *\r
1467 * SEE ALSO\r
1468 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_query_qp, uvp_post_query_qp_t,\r
1469 *       uvp_pre_modify_qp, uvp_post_modify_qp_t, uvp_post_destroy_qp_t\r
1470 *\r
1471 ********/\r
1472 \r
1473 /********/\r
1474 \r
1475 \r
1476 /****f* user-mode Verbs/uvp_post_destroy_qp_t\r
1477 * NAME\r
1478 *       uvp_post_destroy_qp_t -- Post-ioctl function to Destroy a Queue Pair.\r
1479 *\r
1480 * SYNOPSIS\r
1481 */\r
1482 \r
1483 typedef void\r
1484 (AL_API *uvp_post_destroy_qp_t) (\r
1485         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
1486         IN                              ib_api_status_t                         ioctl_status );\r
1487 \r
1488 /*\r
1489 * DESCRIPTION\r
1490 *       uvp_post_destroy_qp_t() is implemented by vendor. It is the post-ioctl\r
1491 *       routine for ib_destroy_qp().\r
1492 *       UAL invokes this post-ioctl routine to destroy QP when it receives\r
1493 *       asynchronous notification from the user-mode proxy in kernel.\r
1494 *\r
1495 * PARAMETERS\r
1496 *       h_uvp_qp\r
1497 *               [in] Vendor's Handle to the qp (in user-mode library)\r
1498 *               that needs to be destroyed.\r
1499 *\r
1500 * RETURN VALUE\r
1501 *       IB_SUCCESS\r
1502 *               The post-ioctl call is successful.\r
1503 *\r
1504 * PORTABILITY\r
1505 *       User mode.\r
1506 *\r
1507 * SEE ALSO\r
1508 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_query_qp, uvp_post_query_qp_t,\r
1509 *       uvp_pre_modify_qp, uvp_post_modify_qp_t, uvp_pre_destroy_qp\r
1510 *\r
1511 ********/\r
1512 \r
1513 /********/\r
1514 \r
1515 /****f* user-mode Verbs/uvp_pre_create_cq\r
1516 * NAME\r
1517 *       uvp_pre_create_cq -- Pre-ioctl function to Create a completion queue (CQ)\r
1518 *\r
1519 * SYNOPSIS\r
1520 */\r
1521 \r
1522 typedef ib_api_status_t\r
1523 (AL_API *uvp_pre_create_cq) (\r
1524         IN              const   ib_ca_handle_t                          h_uvp_ca,\r
1525         IN      OUT                     uint32_t*                       const   p_size,\r
1526         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1527 /*\r
1528 * DESCRIPTION\r
1529 *       uvp_pre_create_cq() is implemented by vendor. It is the pre-ioctl routine\r
1530 *       for ib_create_cq().\r
1531 *\r
1532 * PARAMETERS\r
1533 *       h_uvp_pd\r
1534 *               [in] Vendor's handle to an existing protection domain (in user-mode\r
1535 *               library)\r
1536 *       p_size\r
1537 *               [in out] Points to a variable containing the number of CQ entries\r
1538 *               requested by the consumer.\r
1539 *               On return,  points to the size of the CQ that was created\r
1540 *               by the provider.\r
1541 *       p_umv_buf\r
1542 *               [in out] On input, UAL provides this buffer template.\r
1543 *               On return from this function, p_umv_buf contains\r
1544 *               any vendor-specific record to be exchanged with the vendor's\r
1545 *               HCA driver.\r
1546 *\r
1547 * RETURN VALUE\r
1548 *       IB_SUCCESS\r
1549 *               The operation was successful.\r
1550 *       IB_INVALID_PD_HANDLE\r
1551 *               The h_uvp_pd passed is invalid.\r
1552 *       IB_INSUFFICIENT_RESOURCES\r
1553 *               Insufficient resources to complete request.\r
1554 *       IB_INVALID_CQ_SIZE\r
1555 *               Requested CQ Size is not supported.\r
1556 *\r
1557 * PORTABILITY\r
1558 *       User mode.\r
1559 *\r
1560 * SEE ALSO\r
1561 *       uvp_post_create_cq_t, uvp_pre_resize_cq, uvp_post_resize_cq_t,\r
1562 *       uvp_pre_query_cq, uvp_post_query_cq_t, uvp_pre_destroy_cq,\r
1563 *       uvp_post_destroy_cq_t\r
1564 *\r
1565 ********/\r
1566 \r
1567 /********/\r
1568 \r
1569 /****f* user-mode Verbs/uvp_post_create_cq_t\r
1570 * NAME\r
1571 *       uvp_post_create_cq_t -- Post-ioctl function to Create a completion queue (CQ)\r
1572 *\r
1573 * SYNOPSIS\r
1574 */\r
1575 \r
1576 typedef void\r
1577 (AL_API *uvp_post_create_cq_t) (\r
1578         IN              const   ib_ca_handle_t                          h_uvp_ca,\r
1579         IN                              ib_api_status_t                         ioctl_status,\r
1580         IN              const   uint32_t                                        size,\r
1581                 OUT                     ib_cq_handle_t                          *ph_uvp_cq,\r
1582         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1583 \r
1584 /*\r
1585 * DESCRIPTION\r
1586 *       uvp_post_create_cq_t() is implemented by vendor to create CQ.\r
1587 *       It is the post-ioctl routine for ib_create_cq().\r
1588 *\r
1589 * PARAMETERS\r
1590 *       h_uvp_pd\r
1591 *               [in] Vendor's handle to an existing protection domain (in user-mode\r
1592 *               library)\r
1593 *       ioctl_status\r
1594 *               [in] The ioctl status of the AL API.\r
1595 *       size\r
1596 *               [in] size of the CQ that was created by the provider.\r
1597 *               If VPD created the CQ in kernel, this is the value as set by\r
1598 *               VPD. If UVP creates the CQ in user-mode, then uvp already knows\r
1599 *               the size of the CQ in the pre-ioctl.\r
1600 *       ph_uvp_cq\r
1601 *               [out] Vendor's Handle to the newly created CQ (in user-mode library).\r
1602 *       p_umv_buf\r
1603 *               [in out] On input, it contains any vendor-specific private information\r
1604 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_create_cq).\r
1605 *               Vendor is expected to check vendor-specific status in\r
1606 *               umv_buf as appropriate.\r
1607 *\r
1608 * RETURN VALUE\r
1609 *       This function does not return a value.\r
1610 *\r
1611 * PORTABILITY\r
1612 *       User mode.\r
1613 *\r
1614 * SEE ALSO\r
1615 *       uvp_pre_create_cq, uvp_pre_resize_cq, uvp_post_resize_cq_t,\r
1616 *       uvp_pre_query_cq, uvp_post_query_cq_t, uvp_pre_destroy_cq,\r
1617 *       uvp_post_destroy_cq_t\r
1618 *\r
1619 ********/\r
1620 \r
1621 /********/\r
1622 \r
1623 /****f* user-mode Verbs/uvp_pre_resize_cq\r
1624 * NAME\r
1625 *       uvp_pre_resize_cq -- Pre-ioctl function to resize a CQ.\r
1626 *\r
1627 * SYNOPSIS\r
1628 */\r
1629 \r
1630 typedef ib_api_status_t\r
1631 (AL_API *uvp_pre_resize_cq) (\r
1632         IN              const   ib_cq_handle_t                          h_uvp_cq,\r
1633         IN      OUT                     uint32_t*                       const   p_size,\r
1634         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1635 \r
1636 /*\r
1637 * DESCRIPTION\r
1638 *       uvp_pre_resize_cq() is implemented by vendor to resize the CQ.\r
1639 *       It is the pre-ioctl routine for ib_resize_cq().\r
1640 *\r
1641 * PARAMETERS\r
1642 *       h_uvp_cq\r
1643 *               [in] Vendor's Handle to the already created CQ (in user-mode library).\r
1644 *       p_size\r
1645 *               [in out] On input, points to a variable containing the number\r
1646 *               of CQ entries requested by the consumer.\r
1647 *               On completion points to the size of the CQ that was resized by\r
1648 *               the provider.\r
1649 *       p_umv_buf\r
1650 *               [in out] On input, UAL provides this buffer template.\r
1651 *               On return from this function, p_umv_buf contains\r
1652 *               any vendor-specific record to be exchanged with the vendor's\r
1653 *               HCA driver.\r
1654 \r
1655 * RETURN VALUE\r
1656 *       IB_SUCCESS\r
1657 *               The operation was successful.\r
1658 *       IB_INVALID_CQ_HANDLE\r
1659 *               The CQ handle is invalid.\r
1660 *       IB_INSUFFICIENT_RESOURCES\r
1661 *               Insufficient resources to complete request.\r
1662 *       IB_INVALID_CQ_SIZE\r
1663 *               Requested CQ Size is not supported.\r
1664 *       IB_OVERFLOW\r
1665 *               The CQ has more entries than the resize request. The CQ is not\r
1666 *               modified, and old entries still exist.\r
1667 *\r
1668 * PORTABILITY\r
1669 *       User mode.\r
1670 *\r
1671 * SEE ALSO\r
1672 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_post_resize_cq_t,\r
1673 *       uvp_pre_query_cq, uvp_post_query_cq_t, uvp_pre_destroy_cq,\r
1674 *       uvp_post_destroy_cq_t\r
1675 *\r
1676 ********/\r
1677 \r
1678 /********/\r
1679 \r
1680 /****f* user-mode Verbs/uvp_post_resize_cq_t\r
1681 * NAME\r
1682 *       uvp_post_resize_cq_t -- Post-ioctl function to resize a CQ.\r
1683 *\r
1684 * SYNOPSIS\r
1685 */\r
1686 \r
1687 typedef void\r
1688 (AL_API *uvp_post_resize_cq_t) (\r
1689         IN              const   ib_cq_handle_t                          h_uvp_cq,\r
1690         IN                              ib_api_status_t                         ioctl_status,\r
1691         IN              const   uint32_t                                        size,\r
1692         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1693 \r
1694 /*\r
1695 * DESCRIPTION\r
1696 *       uvp_post_resize_cq_t() is implemented by vendor to resize the CQ.\r
1697 *       It is the post-ioctl routine for ib_resize_cq().\r
1698 *\r
1699 * PARAMETERS\r
1700 *       h_uvp_cq\r
1701 *               [in] Vendor's Handle to the already created CQ (in user-mode library).\r
1702 *       ioctl_status\r
1703 *               [in] The ioctl status of the AL API.\r
1704 *       size\r
1705 *               [in] size of the CQ that was created by the provider.\r
1706 *               If VPD resized the CQ in kernel, this is the value as set by\r
1707 *               VPD. If UVP resizes the CQ in user-mode, then uvp already knows\r
1708 *               the size of the CQ in the pre-ioctl.\r
1709 *       p_umv_buf\r
1710 *               [in out] On input, it contains any vendor-specific private information\r
1711 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_resize_cq).\r
1712 *               Vendor is expected to check vendor-specific status in\r
1713 *               umv_buf as appropriate.\r
1714 *\r
1715 * RETURN VALUE\r
1716 *       This function does not return a value.\r
1717 *\r
1718 * PORTABILITY\r
1719 *       User mode.\r
1720 *\r
1721 * SEE ALSO\r
1722 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_pre_resize_cq,\r
1723 *       uvp_pre_query_cq, uvp_post_query_cq_t, uvp_pre_destroy_cq,\r
1724 *       uvp_post_destroy_cq_t\r
1725 *\r
1726 ********/\r
1727 \r
1728 /********/\r
1729 \r
1730 /****f* user-mode Verbs/uvp_pre_query_cq\r
1731 * NAME\r
1732 *       uvp_pre_query_cq -- Pre-ioctl to Query the number of entries\r
1733 *                                               configured for the CQ.\r
1734 *\r
1735 * SYNOPSIS\r
1736 */\r
1737 \r
1738 typedef ib_api_status_t\r
1739 (AL_API *uvp_pre_query_cq) (\r
1740         IN              const   ib_cq_handle_t                          h_uvp_cq,\r
1741         IN      OUT                     uint32_t* const                         p_size,\r
1742         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1743 \r
1744 /*\r
1745 * DESCRIPTION\r
1746 *       uvp_pre_query_cq() is implemented by vendor. It is the pre-ioctl routine\r
1747 *       for ib_query_cq().\r
1748 *       Can we always go to the kernel to query even if it is created\r
1749 *       in vendor library in user-mode?\r
1750 *\r
1751 * PARAMETERS\r
1752 *       h_uvp_cq\r
1753 *               [in] Vendor's Handle to the already created CQ (in user-mode library).\r
1754 *\r
1755 *       p_size\r
1756 *               [out] Size of the CQ if processing ends in user-mode.\r
1757 *\r
1758 *       p_umv_buf\r
1759 *               [in out] On input, UAL provides this buffer template.\r
1760 *               On return from this function, p_umv_buf contains\r
1761 *               any vendor-specific record to be exchanged with the vendor's\r
1762 *               HCA driver.\r
1763 *\r
1764 * RETURN VALUE\r
1765 *       IB_SUCCESS\r
1766 *               The operation was successful.\r
1767 *       IB_INVALID_CQ_HANDLE\r
1768 *               The CQ handle is invalid.\r
1769 *       IB_INSUFFICIENT_RESOURCES\r
1770 *               Insufficient resources in Vendor library to complete the call.\r
1771 *       IB_VERBS_PROCESSING_DONE\r
1772 *               The UVP fully processed the request.  The post_query_cq handler\r
1773 *               will not be invoked.\r
1774 *\r
1775 * PORTABILITY\r
1776 *       User mode.\r
1777 * SEE ALSO\r
1778 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_pre_resize_cq,\r
1779 *       uvp_post_resize_cq_t, uvp_post_query_cq_t, uvp_pre_destroy_cq,\r
1780 *       uvp_post_destroy_cq_t\r
1781 *\r
1782 ********/\r
1783 \r
1784 /********/\r
1785 \r
1786 /****f* user-mode Verbs/uvp_post_query_cq_t\r
1787 * NAME\r
1788 *       uvp_post_query_cq_t -- Post-ioctl to Query the number of entries\r
1789 *                                                configured for the CQ.\r
1790 *\r
1791 * SYNOPSIS\r
1792 */\r
1793 \r
1794 typedef void\r
1795 (AL_API *uvp_post_query_cq_t) (\r
1796         IN              const   ib_cq_handle_t                          h_uvp_cq,\r
1797         IN                              ib_api_status_t                         ioctl_status,\r
1798         IN              const   uint32_t                                        size,\r
1799         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1800 \r
1801 /*\r
1802 * DESCRIPTION\r
1803 *       uvp_post_query_cq_t() is implemented by vendor to query CQ.\r
1804 *       It is the post-ioctl routine for ib_query_cq().\r
1805 *\r
1806 * PARAMETERS\r
1807 *       h_uvp_cq\r
1808 *               [in] Vendor's Handle to the already created CQ (in user-mode library).\r
1809 *       ioctl_status\r
1810 *               [in] The ioctl status of the AL API.\r
1811 *       size\r
1812 *               [in] The size of the CQ retuned by the IOCTL.\r
1813 *       p_umv_buf\r
1814 *               [in out] On input, it contains any vendor-specific private information\r
1815 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_query_cq).\r
1816 *               Vendor is expected to check vendor-specific status in\r
1817 *               umv_buf as appropriate.\r
1818 *\r
1819 * RETURN VALUE\r
1820 *       This function does not return a value.\r
1821 *\r
1822 * PORTABILITY\r
1823 *       User mode.\r
1824 *\r
1825 * SEE ALSO\r
1826 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_pre_resize_cq,\r
1827 *       uvp_post_resize_cq_t, uvp_pre_query_cq, uvp_pre_destroy_cq,\r
1828 *       uvp_post_destroy_cq_t\r
1829 *\r
1830 ********/\r
1831 \r
1832 /********/\r
1833 \r
1834 /****f* user-mode Verbs/uvp_pre_destroy_cq\r
1835 * NAME\r
1836 *       uvp_pre_destroy_cq -- Pre-ioctl function to Destroy a CQ.\r
1837 *\r
1838 * SYNOPSIS\r
1839 */\r
1840 \r
1841 typedef ib_api_status_t\r
1842 (AL_API *uvp_pre_destroy_cq) (\r
1843         IN              const   ib_cq_handle_t                          h_uvp_cq );\r
1844 \r
1845 /*\r
1846 * DESCRIPTION\r
1847 *       uvp_pre_destroy_cq() is implemented by vendor to destroy CQ.\r
1848 *       It is the pre-ioctl routine for ib_destroy_cq().\r
1849 *\r
1850 * PARAMETERS\r
1851 *       h_uvp_cq\r
1852 *               [in] Vendor's Handle to the cq (in user-mode library)\r
1853 *               that needs to be destroyed.\r
1854 *\r
1855 * RETURN VALUE\r
1856 *       IB_SUCCESS\r
1857 *               The pre-ioctl call is successful.\r
1858 *\r
1859 * PORTABILITY\r
1860 *       User mode.\r
1861 *\r
1862 * SEE ALSO\r
1863 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_pre_resize_cq,\r
1864 *       uvp_post_resize_cq_t, uvp_pre_query_cq, uvp_post_query_cq_t,\r
1865 *       uvp_post_destroy_cq_t\r
1866 *\r
1867 ********/\r
1868 \r
1869 /********/\r
1870 \r
1871 /****f* user-mode Verbs/uvp_post_destroy_cq_t\r
1872 * NAME\r
1873 *       uvp_post_destroy_cq_t -- Post-ioctl function to Destroy a CQ.\r
1874 *\r
1875 * SYNOPSIS\r
1876 */\r
1877 \r
1878 typedef void\r
1879 (AL_API *uvp_post_destroy_cq_t) (\r
1880         IN              const   ib_cq_handle_t                          h_uvp_cq,\r
1881         IN                              ib_api_status_t                         ioctl_status );\r
1882 \r
1883 /*\r
1884 * DESCRIPTION\r
1885 *       uvp_post_destroy_cq_t() is implemented by vendor to destroy CQ.\r
1886 *       It is the post-ioctl routine for ib_destroy_cq().\r
1887 *       UAL invokes this post-ioctl routine to destroy CQ when it receives\r
1888 *       asynchronous notification from the user-mode proxy.\r
1889 *\r
1890 * PARAMETERS\r
1891 *       h_uvp_cq\r
1892 *               [in] Vendor's Handle to the cq (in user-mode library)\r
1893 *               that needs to be destroyed.\r
1894 * RETURN VALUE\r
1895 *       This function does not return a value.\r
1896 *\r
1897 * PORTABILITY\r
1898 *       User mode.\r
1899 *\r
1900 * SEE ALSO\r
1901 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_pre_resize_cq,\r
1902 *       uvp_post_resize_cq_t, uvp_pre_query_cq, uvp_post_query_cq_t,\r
1903 *       uvp_pre_destroy_cq\r
1904 *\r
1905 ********/\r
1906 \r
1907 /********/\r
1908 \r
1909 /****f* user-mode Verbs/uvp_pre_create_mw\r
1910 * NAME\r
1911 *       uvp_pre_create_mw -- Pre-ioctl function to create a memory window\r
1912 *\r
1913 * SYNOPSIS\r
1914 */\r
1915 \r
1916 typedef ib_api_status_t\r
1917 (AL_API *uvp_pre_create_mw) (\r
1918         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
1919         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
1920 /*\r
1921 * DESCRIPTION\r
1922 *       uvp_pre_create_mw() is implemented by vendor. It is the pre-ioctl routine\r
1923 *       for ib_create_mw().\r
1924 *\r
1925 * PARAMETERS\r
1926 *       h_uvp_pd\r
1927 *               [in] Vendor's Protection domain handle (in user-mode library)\r
1928 *               to use for this memory window\r
1929 *       p_umv_buf\r
1930 *               [in out] On input, UAL provides this buffer template.\r
1931 *               On return from this function, p_umv_buf contains\r
1932 *               any vendor-specific record to be exchanged with the vendor's\r
1933 *               HCA driver.\r
1934 *\r
1935 * RETURN VALUE\r
1936 *       IB_SUCCESS\r
1937 *               The memory window allocation completed successfully.\r
1938 *       IB_INSUFFICIENT_RESOURCES\r
1939 *               Not enough resources to complete the request.\r
1940 *       IB_INVALID_PD_HANDLE\r
1941 *               pd_handle supplied is invalid.\r
1942 *\r
1943 * PORTABILITY\r
1944 *       User mode\r
1945 *\r
1946 * SEE ALSO\r
1947 *       uvp_post_create_mw_t, uvp_pre_query_mw, uvp_post_query_mw_t,\r
1948 *       uvp_bind_mw, uvp_pre_destroy_mw, uvp_post_destroy_mw_t\r
1949 *\r
1950 ********/\r
1951 \r
1952 \r
1953 /********/\r
1954 \r
1955 \r
1956 /****f* user-mode Verbs/uvp_post_create_mw_t\r
1957 * NAME\r
1958 *       uvp_post_create_mw_t -- Post-ioctl function to create a memory window\r
1959 *\r
1960 * SYNOPSIS\r
1961 */\r
1962 \r
1963 typedef void\r
1964 (AL_API *uvp_post_create_mw_t) (\r
1965         IN              const   ib_pd_handle_t                          h_uvp_pd,\r
1966         IN                              ib_api_status_t                         ioctl_status,\r
1967         IN                              net32_t                                         rkey,\r
1968                 OUT                     ib_mw_handle_t                          *ph_uvp_mw,\r
1969         IN                              ci_umv_buf_t                            *p_umv_buf );\r
1970 /*\r
1971 * DESCRIPTION\r
1972 *       uvp_post_create_mw_t() is implemented by vendor. It is the post-ioctl routine\r
1973 *       for ib_create_mw().\r
1974 *\r
1975 * PARAMETERS\r
1976 *       h_uvp_pd\r
1977 *               [in] Vendor's Protection domain handle (in user-mode library)\r
1978 *               to use for this memory window\r
1979 *       ioctl_status\r
1980 *               [in] The ioctl status of the AL API.\r
1981 *       p_rkey\r
1982 *               [in] Remote access key that can be exchanged with a remote node to\r
1983 *               perform RDMA transactions on this memory window.\r
1984 *       ph_uvp_mw\r
1985 *               [out] Vendor's Handle (in user-mode library) to the newly created\r
1986 *               memory window.\r
1987 *       p_umv_buf\r
1988 *               [in out] On input, it contains any vendor-specific private information\r
1989 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_create_mw).\r
1990 *               Vendor is expected to check vendor-specific status in\r
1991 *               umv_buf as appropriate.\r
1992 *\r
1993 * RETURN VALUE\r
1994 *       This function does not return an error.\r
1995 *\r
1996 * PORTABILITY\r
1997 *       User mode\r
1998 *\r
1999 * SEE ALSO\r
2000 *       uvp_pre_create_mw, uvp_pre_query_mw, uvp_post_query_mw_t,\r
2001 *       uvp_bind_mw, uvp_pre_destroy_mw, uvp_post_destroy_mw_t\r
2002 *\r
2003 ********/\r
2004 \r
2005 /********/\r
2006 \r
2007 /****f* user-mode Verbs/uvp_pre_query_mw\r
2008 * NAME\r
2009 *       uvp_pre_query_mw -- Pre-ioctl to Query a memory window\r
2010 *\r
2011 * SYNOPSIS\r
2012 */\r
2013 \r
2014 typedef ib_api_status_t\r
2015 (AL_API *uvp_pre_query_mw) (\r
2016         IN              const   ib_mw_handle_t                          h_uvp_mw,\r
2017         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
2018 \r
2019 /*\r
2020 * DESCRIPTION\r
2021 *       uvp_pre_query_mw is implemented by vendor. It is the pre-ioctl routine\r
2022 *       for ib_query_mw().\r
2023 *\r
2024 * PARAMETERS\r
2025 *       h_uvp_mw\r
2026 *               [in] Vendor's  Memory window handle (in user-mode library)\r
2027 *               whose attributes are being retrieved.\r
2028 *       p_umv_buf\r
2029 *               [in out] On input, UAL provides this buffer template.\r
2030 *               On return from this function, p_umv_buf contains\r
2031 *               any vendor-specific record to be exchanged with the vendor's\r
2032 *               HCA driver.\r
2033 * RETURN VALUE\r
2034 *       IB_SUCCESS\r
2035 *               The pre-ioctl call completed successfully.\r
2036 *       IB_INVALID_MW_HANDLE\r
2037 *               mw_handle supplied is an invalid handle.\r
2038 *       IB_INSUFFICIENT_RESOURCES\r
2039 *               Not enough resources to complete the request.\r
2040 *\r
2041 * PORTABILITY\r
2042 *       User mode\r
2043 *\r
2044 * SEE ALSO\r
2045 *       uvp_pre_create_mw, uvp_post_create_mw_t, uvp_post_query_mw_t,\r
2046 *       uvp_bind_mw, uvp_pre_destroy_mw, uvp_post_destroy_mw_t\r
2047 *\r
2048 ********/\r
2049 \r
2050 /********/\r
2051 \r
2052 /****f* user-mode Verbs/uvp_post_query_mw_t\r
2053 * NAME\r
2054 *       uvp_post_query_mw_t -- Post-ioctl to Query a memory window\r
2055 *\r
2056 * SYNOPSIS\r
2057 */\r
2058 \r
2059 typedef void\r
2060 (AL_API *uvp_post_query_mw_t) (\r
2061         IN              const   ib_mw_handle_t                          h_uvp_mw,\r
2062         IN                              ib_api_status_t                         ioctl_status,\r
2063         IN                              net32_t                                         rkey,\r
2064                 OUT                     ib_pd_handle_t                          *ph_pd,\r
2065         IN                              ci_umv_buf_t                            *p_umv_buf );\r
2066 /*\r
2067 * DESCRIPTION\r
2068 *       uvp_post_query_mw_t is implemented by vendor. It is the post-ioctl routine\r
2069 *       for ib_query_mw().\r
2070 *\r
2071 * PARAMETERS\r
2072 *       h_uvp_mw\r
2073 *               [in] Vendor's  Memory window handle (in user-mode library)\r
2074 *               whose attributes are being retrieved.\r
2075 *       ioctl_status\r
2076 *               [in] The ioctl status of the AL API.\r
2077 *       rkey\r
2078 *               [in] Current R_KEY associated with this mw_handle\r
2079 *       ph_pd\r
2080 *               [in] Protection domain handle associated with this mw_handle\r
2081 *       p_umv_buf\r
2082 *               [in out] On input, it contains any vendor-specific private information\r
2083 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_query_mw).\r
2084 *               Vendor is expected to check vendor-specific status in\r
2085 *               umv_buf as appropriate.\r
2086 *\r
2087 * RETURN VALUE\r
2088 *       IB_SUCCESS\r
2089 *               The query operation completed successfully.\r
2090 *\r
2091 * PORTABILITY\r
2092 *       User mode\r
2093 *\r
2094 * SEE ALSO\r
2095 *       uvp_pre_create_mw, uvp_post_create_mw_t, uvp_pre_query_mw,\r
2096 *       uvp_bind_mw, uvp_pre_destroy_mw, uvp_post_destroy_mw_t\r
2097 *\r
2098 ********/\r
2099 \r
2100 /********/\r
2101 \r
2102 /****f* user-mode Verbs/uvp_bind_mw\r
2103 * NAME\r
2104 *       uvp_bind_mw -- Bind a memory window to a memory region.\r
2105 *\r
2106 * SYNOPSIS\r
2107 */\r
2108 \r
2109 typedef ib_api_status_t\r
2110 (AL_API *uvp_bind_mw) (\r
2111         IN              const   ib_mw_handle_t                          h_uvp_mw,\r
2112         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
2113         IN                              ib_bind_wr_t                            *p_mw_bind,\r
2114                 OUT                     net32_t* const                          p_rkey );\r
2115 /*\r
2116 * DESCRIPTION\r
2117 *       This routine posts a request to bind a memory window to a registered\r
2118 *       memory region. If the queue pair was created with selectable signaling,\r
2119 *       once the operation is completed successfully then a completion queue entry\r
2120 *       is generated indicating the bind operation has completed. The IB_POST_FENCE\r
2121 *       option could be specified to cause the requestor to wait until outstanding\r
2122 *       RDMA operations can be completed.\r
2123 *\r
2124 * PARAMETERS\r
2125 *       h_uvp_mw\r
2126 *               [in] Vendor's Handle (in user-mode library) to memory window\r
2127 *               that needs to be bound to a memory region.\r
2128 *       h_uvp_qp\r
2129 *               [in] Vendor's QP Handle (in user-mode library) to which\r
2130 *               this bind request is to be posted.\r
2131 *       p_mw_bind\r
2132 *               [in] Input parameters for this bind request, consisting of virtual\r
2133 *               addr range of bind request etc. On successful completion, the new R_KEY\r
2134 *               is returned.\r
2135 *       p_rkey\r
2136 *               [out] Current R_KEY associated with this mw_handle\r
2137 *\r
2138 * RETURN VALUE\r
2139 *       IB_SUCCESS\r
2140 *               The memory bind operation was posted successfully.\r
2141 *       IB_INSUFFICIENT_RESOURCES\r
2142 *               Insufficient resources to complete the request.\r
2143 *               No more WQE's to post this request\r
2144 *               No more free WQE's to post this request\r
2145 *       IB_INVALID_MW_HANDLE\r
2146 *               memw_handle supplied is an invalid memory window handle.\r
2147 *       IB_INVALID_PERMISSION\r
2148 *               Invalid access rights specified in request\r
2149 *       IB_INVALID_SERVICE_TYPE\r
2150 *               Invalid service type for this qp_handle.\r
2151 *       IB_INVALID_PARAMETER\r
2152 *               Address or length parameter specified is invalid.\r
2153 *       IB_INVALID_RKEY\r
2154 *               R_KEY specified is invalid for the memory region being bound.\r
2155 *\r
2156 * PORTABILITY\r
2157 *       User mode.\r
2158 *\r
2159 * SEE ALSO\r
2160 *       uvp_pre_create_mw, uvp_post_create_mw_t, uvp_pre_query_mw,\r
2161 *       uvp_post_query_mw_t, uvp_pre_destroy_mw, uvp_post_destroy_mw_t\r
2162 *\r
2163 ********/\r
2164 \r
2165 /********/\r
2166 \r
2167 /****f* user-mode Verbs/uvp_pre_destroy_mw\r
2168 * NAME\r
2169 *       uvp_pre_destroy_mw -- Pre-ioctl function to destroy a memory window\r
2170 *\r
2171 * SYNOPSIS\r
2172 */\r
2173 \r
2174 typedef ib_api_status_t\r
2175 (AL_API *uvp_pre_destroy_mw) (\r
2176         IN              const   ib_mw_handle_t                          h_uvp_mw );\r
2177 \r
2178 /*\r
2179 * DESCRIPTION\r
2180 *       uvp_pre_destroy_mw() is implemented by vendor. It is the pre-ioctl routine\r
2181 *       for ib_destroy_mw().\r
2182 *\r
2183 *\r
2184 * PARAMETERS\r
2185 *       h_uvp_mw\r
2186 *               [in] Vendor's handle (in user-mode library) to the memory window\r
2187 *\r
2188 * RETURN VALUE\r
2189 *       IB_SUCCESS\r
2190 *               Pre-ioctl succeeded.\r
2191 *\r
2192 * PORTABILITY\r
2193 *       User mode\r
2194 \r
2195 * SEE ALSO\r
2196 *       uvp_pre_create_mw, uvp_post_create_mw_t, uvp_pre_query_mw,\r
2197 *       uvp_post_query_mw_t, uvp_bind_mw, uvp_post_destroy_mw_t\r
2198 *\r
2199 ********/\r
2200 \r
2201 /********/\r
2202 \r
2203 /****f* user-mode Verbs/uvp_post_destroy_mw_t\r
2204 * NAME\r
2205 *       uvp_post_destroy_mw_t -- Post-ioctl function to destroy a memory window\r
2206 *\r
2207 * SYNOPSIS\r
2208 */\r
2209 \r
2210 typedef void\r
2211 (AL_API *uvp_post_destroy_mw_t) (\r
2212         IN              const   ib_mw_handle_t                          h_uvp_mw,\r
2213         IN                              ib_api_status_t                         ioctl_status );\r
2214 /*\r
2215 * DESCRIPTION\r
2216 *       uvp_post_destroy_mw_t() is implemented by vendor. It is the post-ioctl\r
2217 *       routine to destroy a memory window.\r
2218 *\r
2219 *\r
2220 * PARAMETERS\r
2221 *       h_uvp_mw\r
2222 *               [in] Vendor's handle to the memory window\r
2223 *\r
2224 * RETURN VALUE\r
2225 *       IB_SUCCESS\r
2226 *               Destroy operation successful.\r
2227 *\r
2228 * PORTABILITY\r
2229 *       User mode\r
2230 *\r
2231 * SEE ALSO\r
2232 *       uvp_pre_create_mw, uvp_post_create_mw_t, uvp_pre_query_mw,\r
2233 *       uvp_post_query_mw_t, uvp_bind_mw, uvp_pre_destroy_mw\r
2234 *\r
2235 ********/\r
2236 \r
2237 /********/\r
2238 \r
2239 /****f* user-mode Verbs/uvp_post_send\r
2240 * NAME\r
2241 *       uvp_post_send -- Post a work request to the send side of a queue pair.\r
2242 *\r
2243 * SYNOPSIS\r
2244 */\r
2245 \r
2246 typedef ib_api_status_t\r
2247 (AL_API *uvp_post_send) (\r
2248         IN              const   void*           __ptr64                 h_qp,\r
2249         IN                              ib_send_wr_t*   const           p_send_wr,\r
2250                 OUT                     ib_send_wr_t**                          pp_send_failure );\r
2251 /*\r
2252 * DESCRIPTION\r
2253 *       This routine posts a work request to the send side of the queue pair.\r
2254 *       The different types of work request that can be posted are explained in\r
2255 *       the ib_wr_t structure. For exact details on ordering rules please consult\r
2256 *       the Volume 1, of the InfiniBand Specifications. If there is more\r
2257 *       outstanding requests posted that what the queue is configured for, an\r
2258 *       immediate error is returned.\r
2259 *\r
2260 * PARAMETERS\r
2261 *       h_qp\r
2262 *               [in] Type-cast as appropriate for user/kernel mode, this is\r
2263 *               the Queue pair handle to which the receive work request is being\r
2264 *               posted.\r
2265 *       p_send_wr\r
2266 *               [in] List of work requests that needs to be send.\r
2267 *       pp_send_failure\r
2268 *               [out] The work requests that failed.\r
2269 *\r
2270 * RETURN VALUE\r
2271 *       Any unsuccessful status indicates the status of the first failed request.\r
2272 *\r
2273 *       IB_SUCCESS\r
2274 *               All the work requests are completed successfully\r
2275 *       IB_INVALID_QP_HANDLE\r
2276 *               The qp_handle supplied is invalid.\r
2277 *       IB_INSUFFICIENT_RESOURCES\r
2278 *               Insufficient resources to complete the request.\r
2279 *               There are no more work elements in the channel interface to\r
2280 *               process this request, and the total outstanding work request has\r
2281 *               been exceeded.\r
2282 *       IB_INVALID_WR_TYPE\r
2283 *               The work request type was not valid.\r
2284 *       IB_INVALID_QP_STATE\r
2285 *               The queue pair is either in Reset, Init, RTR or Error state.\r
2286 *       IB_INVALID_MAX_SGE\r
2287 *               The work request has too many scatter gather elements than what the\r
2288 *               QP is configured.\r
2289 *       IB_UNSUPPORTED\r
2290 *               Atomics or Reliable datagram request is not supported by this HCA.\r
2291 *       IB_INVALID_ADDR_HANDLE\r
2292 *               Address handle supplied in the work request is invalid.\r
2293 *\r
2294 * PORTABILITY\r
2295 *       Kernel & User mode.\r
2296 *\r
2297 * NOTES\r
2298 *       Please refer to Table 81 and Table 82 for allowed operation types\r
2299 *       on different types of queue pairs, and the different modifiers\r
2300 *       acceptable for the work request for different QP service types.\r
2301 *\r
2302 * SEE ALSO\r
2303 *       uvp_post_recv, uvp_poll_cq\r
2304 *\r
2305 ********/\r
2306 \r
2307 /********/\r
2308 \r
2309 /****f* user-mode Verbs/uvp_post_recv\r
2310 * NAME\r
2311 *       uvp_post_recv -- Post a work request to the receive queue of a queue pair.\r
2312 *\r
2313 * SYNOPSIS\r
2314 */\r
2315 \r
2316 typedef ib_api_status_t\r
2317 (AL_API *uvp_post_recv) (\r
2318         IN              const   void* __ptr64                           h_qp,\r
2319         IN                              ib_recv_wr_t*   const           p_recv_wr,\r
2320                 OUT                     ib_recv_wr_t**                          pp_recv_failure );\r
2321 \r
2322 /*\r
2323 * DESCRIPTION\r
2324 *       This routine allows to queue a work request to the receive side of a\r
2325 *       queue pair. The work_req holds necessary data to satisfy an incoming\r
2326 *       receive message. If an attempt is made to queue more work requests than\r
2327 *       what is available, an error is returned.\r
2328 *\r
2329 * PARAMETERS\r
2330 *       h_qp\r
2331 *               [in] Type-cast as appropriate for user/kernel mode, this is\r
2332 *               the Queue pair handle to which the receive work request is being\r
2333 *               posted.\r
2334 *       p_recv_wr\r
2335 *               [in] List of recv work requests that needs to be posted.\r
2336 *       pp_recv_failure\r
2337 *               [out] The work requests that failed.\r
2338 \r
2339 * RETURN VALUE\r
2340 *       Any unsuccessful status indicates the status of the first failed request.\r
2341 *\r
2342 *       IB_SUCCESS\r
2343 *               The work request was successfully queued to the receive side of the QP.\r
2344 *       IB_INVALID_QP_HANDLE\r
2345 *               qp_handle supplied is not valid.\r
2346 *       IB_INSUFFICIENT_RESOURCES\r
2347 *               The qp has exceeded its receive queue depth than what is has been\r
2348 *               configured.\r
2349 *       IB_INVALID_WR_TYPE\r
2350 *               Invalid work request type found in the request.\r
2351 *       IB_INVALID_QP_STATE\r
2352 *               QP was in reset or init state.\r
2353 *               (TBD: there may be an errata that allows posting in init state)\r
2354 *\r
2355 * PORTABILITY\r
2356 *       Kernel & User mode.\r
2357 *\r
2358 * SEE ALSO\r
2359 *       uvp_post_send, uvp_poll_cq\r
2360 *\r
2361 ********/\r
2362 \r
2363 /********/\r
2364 \r
2365 /****f* user-mode Verbs/uvp_peek_cq\r
2366 * NAME\r
2367 *       uvp_peek_cq\r
2368 *\r
2369 * DESCRIPTION\r
2370 *       Returns the number of entries currently on the completion queue.\r
2371 *\r
2372 * SYNOPSIS\r
2373 */\r
2374 \r
2375 typedef ib_api_status_t\r
2376 (AL_API *uvp_peek_cq) (\r
2377         IN              const   void*           __ptr64                 h_cq,\r
2378                 OUT                     uint32_t* const                         p_n_cqes );\r
2379 \r
2380 /*\r
2381 * PARAMETERS\r
2382 *       h_cq\r
2383 *               [in] Type-cast as appropriate for user/kernel mode, this is the\r
2384 *               CQ handle for the completion queue being peeked.\r
2385 *\r
2386 *       p_n_cqes\r
2387 *               [out] Upon successful completion of this call, contains the number\r
2388 *               of completion queue entries currently on the completion queue.\r
2389 *\r
2390 * RETURN VALUES\r
2391 *       IB_SUCCESS\r
2392 *               The peek operation completed successfully.\r
2393 *\r
2394 *       IB_INVALID_CQ_HANDLE\r
2395 *               The completion queue handle was invalid.\r
2396 *\r
2397 *       IB_INVALID_PARAMETER\r
2398 *               A reference to the completion queue entry count was not provided.\r
2399 *\r
2400 * PORTABILITY\r
2401 *       Kernel and User mode\r
2402 *\r
2403 * SEE ALSO\r
2404 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_poll_cq, uvp_rearm_cq,\r
2405 *       uvp_rearm_n_cq\r
2406 *****/\r
2407 \r
2408 /********/\r
2409 \r
2410 /****f* user-mode Verbs/uvp_poll_cq\r
2411 * NAME\r
2412 *       uvp_poll_cq -- Retrieve a work completion record from a completion queue\r
2413 * SYNOPSIS\r
2414 */\r
2415 \r
2416 typedef ib_api_status_t\r
2417 (AL_API *uvp_poll_cq) (\r
2418         IN              const   void*           __ptr64                 h_cq,\r
2419         IN      OUT                     ib_wc_t**       const                   pp_free_wclist,\r
2420                 OUT                     ib_wc_t**       const                   pp_done_wclist );\r
2421 \r
2422 /*\r
2423 * DESCRIPTION\r
2424 *       This routine retrieves a work completion entry from the specified\r
2425 *       completion queue. The contents of the data returned in a work completion\r
2426 *       is specified in ib_wc_t.\r
2427 *\r
2428 * PARAMETERS\r
2429 *       h_cq\r
2430 *               [in] Type-cast as appropriate for user/kernel mode, this is\r
2431 *               the CQ handle for the completion queue being polled.\r
2432 *       pp_free_wclist\r
2433 *               [in out] A list of work request structures provided by the consumer\r
2434 *               for the channel interface to return completed Completion Queue\r
2435 *               entries.  If not all the entries are consumed, this list holds the\r
2436 *               list of un-utilized completion entries provided back to the consumer.\r
2437 *       pp_done_wclist\r
2438 *               [out] A list of work completions retrieved from the completion queue\r
2439 *               and successfully processed.\r
2440 *\r
2441 * RETURN VALUE\r
2442 *       IB_SUCCESS\r
2443 *               Poll completed successfully. If on completion the wc_free list is\r
2444 *               empty, then there are potentially more entries and the consumer must\r
2445 *               be ready to retrieve entries further.\r
2446 *       IB_INVALID_CQ_HANDLE\r
2447 *               The cq_handle supplied is not valid.\r
2448 *       IB_NOT_FOUND\r
2449 *               There are no more entries found in the specified CQ.\r
2450 *\r
2451 * PORTABILITY\r
2452 *       Kernel & User mode.\r
2453 *\r
2454 * SEE ALSO\r
2455 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_rearm_cq,\r
2456 *       uvp_rearm_n_cq, uvp_post_send, uvp_post_recv\r
2457 *\r
2458 ********/\r
2459 \r
2460 /********/\r
2461 \r
2462 /****f* user-mode Verbs/uvp_rearm_cq\r
2463 * NAME\r
2464 *       uvp_rearm_cq -- Invoke the Completion handler, on next entry added.\r
2465 *\r
2466 * SYNOPSIS\r
2467 */\r
2468 \r
2469 typedef ib_api_status_t\r
2470 (AL_API *uvp_rearm_cq) (\r
2471         IN              const   void*           __ptr64                 h_cq,\r
2472         IN              const   boolean_t                                       solicited );\r
2473 \r
2474 /*\r
2475 * DESCRIPTION\r
2476 *       This routine instructs the channel interface to invoke the completion\r
2477 *       handler when the next completion queue entry is added to this CQ.\r
2478 *       Please refer to Volume 1, of the InfiniBand specification for a complete\r
2479 *       description.\r
2480 *\r
2481 * PARAMETERS\r
2482 *       h_cq\r
2483 *               [in] Type-cast as appropriate for user/kernel mode, this is the\r
2484 *               CQ handle for the completion queue being armed.\r
2485 *       solicited\r
2486 *               [in] A boolean flag indicating whether the request is to generate a\r
2487 *               notification on the next entry or on the next solicited entry\r
2488 *               being added to the completion queue.\r
2489 *\r
2490 * RETURN VALUE\r
2491 *       IB_SUCCESS\r
2492 *               The notification request was registered successfully.\r
2493 *       IB_INVALID_CQ_HANDLE\r
2494 *               cq_handle supplied is not a valid handle.\r
2495 *\r
2496 * PORTABILITY\r
2497 *       Kernel and User mode\r
2498 *\r
2499 * SEE ALSO\r
2500 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_peek_cq, uvp_poll_cq,\r
2501 *       uvp_rearm_n_cq\r
2502 *\r
2503 ********/\r
2504 \r
2505 /********/\r
2506 \r
2507 /****f* user-mode Verbs/uvp_rearm_n_cq\r
2508 * NAME\r
2509 *       uvp_rearm_n_cq -- Invoke the Completion handler, when next\r
2510 *       N completions have been added to this CQ.\r
2511 *\r
2512 * SYNOPSIS\r
2513 */\r
2514 \r
2515 typedef ib_api_status_t\r
2516 (AL_API *uvp_rearm_n_cq) (\r
2517         IN              const   void*           __ptr64                 h_cq,\r
2518         IN              const   uint32_t                                        n_cqes );\r
2519 \r
2520 /*\r
2521 * DESCRIPTION\r
2522 *       This routine instructs the channel interface to invoke the completion\r
2523 *       handler when the next N completions are added to this CQ.\r
2524 *\r
2525 * PARAMETERS\r
2526 *       h_cq\r
2527 *               [in] Type-cast as appropriate for user/kernel mode, this is the\r
2528 *               CQ handle for the completion queue being armed.\r
2529 *       n_cqes\r
2530 *               [in] The number of completion queue entries to be added to the\r
2531 *               completion queue before notifying the client.  This value must\r
2532 *               greater than or equal to one and less than or equal to the size\r
2533 *               of the completion queue.\r
2534 *\r
2535 * RETURN VALUE\r
2536 *       IB_SUCCESS\r
2537 *               The notification request was registered successfully.\r
2538 *       IB_INVALID_CQ_HANDLE\r
2539 *               cq_handle supplied is not a valid handle.\r
2540 *       IB_INVALID_PARAMETER\r
2541 *               The requested number of completion queue entries was invalid.\r
2542 *\r
2543 * PORTABILITY\r
2544 *       Kernel and User mode\r
2545 *\r
2546 * SEE ALSO\r
2547 *       uvp_pre_create_cq, uvp_post_create_cq_t, uvp_peek_cq, uvp_poll_cq,\r
2548 *       uvp_rearm_cq\r
2549 *\r
2550 ********/\r
2551 \r
2552 /********/\r
2553 \r
2554 /****f* user-mode Verbs/uvp_pre_attach_mcast\r
2555 * NAME\r
2556 *       uvp_pre_attach_mcast -- Pre-ioctl function to Attach a queue pair\r
2557 *                                                       to a multicast group\r
2558 *\r
2559 * SYNOPSIS\r
2560 */\r
2561 \r
2562 typedef ib_api_status_t\r
2563 (AL_API *uvp_pre_attach_mcast) (\r
2564         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
2565         IN              const   ib_gid_t                                        *p_mcast_gid,\r
2566         IN              const   uint16_t                                        mcast_lid,\r
2567         IN      OUT                     ci_umv_buf_t                            *p_umv_buf );\r
2568 \r
2569 /*\r
2570 * DESCRIPTION\r
2571 *       uvp_pre_attach_mcast() is the pre-ioctl routine implemented by vendor\r
2572 *       to attach a queue pair to a multicast group.\r
2573 *\r
2574 * PARAMETERS\r
2575 *       h_uvp_qp\r
2576 *               [in] Vendor's Queue pair handle (in user-mode library)\r
2577 *               which needs to be added to the multicast group on the adapter.\r
2578 *       mcast_lid\r
2579 *               [in] The multicast group LID value.\r
2580 *       p_mcast_gid\r
2581 *               [in] IPv6 address associated with this multicast group.\r
2582 *       p_umv_buf\r
2583 *               [in out] On input, UAL provides this buffer template.\r
2584 *               On return from this function, p_umv_buf contains\r
2585 *               any vendor-specific record to be exchanged with the vendor's\r
2586 *               HCA driver.\r
2587 *\r
2588 * RETURN VALUE\r
2589 *       IB_SUCCESS\r
2590 *               The queue pair handle was successfully added to the multicast\r
2591 *               group.\r
2592 *       IB_INVALID_QP_HANDLE\r
2593 *               qp_handle supplied is invalid.\r
2594 *       IB_INVALID_SERVICE_TYPE\r
2595 *               Queue pair handle supplied is not of unreliable datagram type.\r
2596 *       IB_INVALID_GID\r
2597 *               The supplied addr is not a valid multicast ipv6 address.\r
2598 *       IB_INSUFFICIENT_RESOURCES\r
2599 *               Insufficient resources to complete the request.\r
2600 *\r
2601 * PORTABILITY\r
2602 *       User mode.\r
2603 *\r
2604 * SEE ALSO\r
2605 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_post_attach_mcast_t,\r
2606 *       uvp_pre_detach_mcast, uvp_post_detach_mcast_t\r
2607 *\r
2608 ********/\r
2609 \r
2610 /********/\r
2611 \r
2612 /****f* user-mode Verbs/uvp_post_attach_mcast_t\r
2613 * NAME\r
2614 *       uvp_post_attach_mcast_t -- Post-ioctl function to Attach a queue pair\r
2615 *                                                        to a multicast group\r
2616 *\r
2617 * SYNOPSIS\r
2618 */\r
2619 \r
2620 typedef void\r
2621 (AL_API *uvp_post_attach_mcast_t) (\r
2622         IN              const   ib_qp_handle_t                          h_uvp_qp,\r
2623         IN                              ib_api_status_t                         ioctl_status,\r
2624                 OUT                     ib_mcast_handle_t                       *ph_mcast,\r
2625         IN                              ci_umv_buf_t                            *p_umv_buf );\r
2626 \r
2627 /*\r
2628 * DESCRIPTION\r
2629 *       uvp_post_attach_mcast_t() is the post-ioctl routine implemented by vendor\r
2630 *       to attach a queue pair to a multicast group.\r
2631 *\r
2632 * PARAMETERS\r
2633 *       h_uvp_qp\r
2634 *               [in] Vendor's Queue pair handle (in user-mode library)\r
2635 *               which needs to be added to\r
2636 *               the multicast group on the adapter.\r
2637 *       ioctl_status\r
2638 *               [in] The ioctl status of the AL API.\r
2639 *       ph_mcast\r
2640 *               [out] Vendor's Multicast handle (in user-mode library)\r
2641 *               holding the association of this queue pair to the multicast group.\r
2642 *       p_umv_buf\r
2643 *               [in out] On input, it contains any vendor-specific private information\r
2644 *               exchanged with the vendor's Verbs Provider Driver (uvp_pre_attach_mcast)\r
2645 *               Vendor is expected to check vendor-specific status in\r
2646 *               umv_buf as appropriate.\r
2647 *\r
2648 * RETURN VALUE\r
2649 *       This function does not return a value.\r
2650 *\r
2651 * PORTABILITY\r
2652 *       Kernel & User mode.\r
2653 *\r
2654 * SEE ALSO\r
2655 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_attach_mcast,\r
2656 *       uvp_pre_detach_mcast, uvp_post_detach_mcast_t\r
2657 *\r
2658 ********/\r
2659 \r
2660 /********/\r
2661 \r
2662 /****f* user-mode Verbs/uvp_pre_detach_mcast\r
2663 * NAME\r
2664 *       uvp_pre_detach_mcast -- Pre-ioctl function to detach a queue pair\r
2665 *                                                       to a multicast group\r
2666 *\r
2667 * SYNOPSIS\r
2668 */\r
2669 \r
2670 typedef ib_api_status_t\r
2671 (AL_API *uvp_pre_detach_mcast) (\r
2672         IN                              ib_mcast_handle_t                       h_uvp_mcast );\r
2673 \r
2674 /*\r
2675 * DESCRIPTION\r
2676 *       uvp_pre_attach_mcast() is the pre-ioctl routine implemented by vendor\r
2677 *       to attach a queue pair to a multicast group.\r
2678 *       Upon return from the pre-ioctl function, UAL packages up the UMV buffer\r
2679 *       in an IOCTL and passes it on to the user-mode proxy. UAL passes the\r
2680 *       info to the user-mode proxy stating that it no longer wishes to receive\r
2681 *       callback for mcast join for the caller.  Note that UAL takes care of\r
2682 *       handling callbcak.\r
2683 *\r
2684 * PARAMETERS\r
2685 *       h_uvp_mcast\r
2686 *               [in] Vendor's Multicast handle (in user-mode library)\r
2687 *               holding the association of this queue pair to the multicast group.\r
2688 *\r
2689 * RETURN VALUE\r
2690 *       IB_SUCCESS\r
2691 *               The queue pair handle was successfully added to the multicast\r
2692 *               group.\r
2693 *\r
2694 * PORTABILITY\r
2695 *       Kernel & User mode.\r
2696 *\r
2697 * SEE ALSO\r
2698 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_attach_mcast,\r
2699 *       uvp_post_attach_mcast_t, uvp_post_detach_mcast_t\r
2700 *\r
2701 ********/\r
2702 \r
2703 /********/\r
2704 \r
2705 /****f* user-mode Verbs/uvp_post_detach_mcast_t\r
2706 * NAME\r
2707 *       uvp_post_detach_mcast_t -- Post-ioctl function to detach a queue pair\r
2708 *                                                        from a multicast group\r
2709 *\r
2710 * SYNOPSIS\r
2711 */\r
2712 \r
2713 typedef void\r
2714 (AL_API *uvp_post_detach_mcast_t) (\r
2715         IN                              ib_mcast_handle_t                       h_uvp_mcast,\r
2716         IN                              ib_api_status_t                         ioctl_status );\r
2717 \r
2718 /*\r
2719 * DESCRIPTION\r
2720 *       uvp_post_detach_mcast_t() is the post-ioctl routine implemented by vendor\r
2721 *       to attach a queue pair to a multicast group.\r
2722 *\r
2723 * PARAMETERS\r
2724 *       h_uvp_mcast\r
2725 *               [out] Vendor's Multicast handle holding the association of this\r
2726 *               queue pair to the multicast group.\r
2727 *       ioctl_status\r
2728 *               [in] The ioctl status of the AL API.\r
2729 *\r
2730 * RETURN VALUE\r
2731 *       This function does not return a value.\r
2732 *\r
2733 * PORTABILITY\r
2734 *       Kernel & User mode.\r
2735 *\r
2736 * SEE ALSO\r
2737 *       uvp_pre_create_qp, uvp_post_create_qp_t, uvp_pre_attach_mcast,\r
2738 *       uvp_post_attach_mcast_t, uvp_pre_detach_mcast\r
2739 *\r
2740 ********/\r
2741 \r
2742 /********/\r
2743 \r
2744 /********/\r
2745 \r
2746 /****s* user-mode Verbs/uvp_interface_t\r
2747 * NAME\r
2748 *       uvp_interface_t -- Interface holding supported Vendor APIs\r
2749 *\r
2750 * PURPOSE\r
2751 *       The following structure is supplied by a Vendor library\r
2752 *       providing verbs functionality.\r
2753 *\r
2754 * SOURCE\r
2755 */\r
2756 typedef struct _uvp_interface\r
2757 {\r
2758         ib_net64_t                                      guid;\r
2759         /*\r
2760          * Version of the header file this interface export can handle\r
2761          */\r
2762         uint32_t                                        version;\r
2763 \r
2764         /*\r
2765          * HCA Access Verbs\r
2766          */\r
2767         uvp_pre_open_ca_t                       pre_open_ca;\r
2768         uvp_post_open_ca_t                      post_open_ca;\r
2769 \r
2770         uvp_pre_query_ca                        pre_query_ca;\r
2771         uvp_post_query_ca_t                     post_query_ca;\r
2772 \r
2773         uvp_pre_modify_ca                       pre_modify_ca;\r
2774         uvp_post_modify_ca_t            post_modify_ca;\r
2775 \r
2776         uvp_pre_close_ca_t                      pre_close_ca;\r
2777         uvp_post_close_ca_t                     post_close_ca;\r
2778 \r
2779         uvp_pre_ci_call                         pre_ci_call;\r
2780         uvp_post_ci_call                        post_ci_call;\r
2781 \r
2782 \r
2783         /*\r
2784          * Protection Domain\r
2785          */\r
2786         uvp_pre_allocate_pd                     pre_allocate_pd;\r
2787         uvp_post_allocate_pd_t          post_allocate_pd;\r
2788         uvp_pre_deallocate_pd           pre_deallocate_pd;\r
2789         uvp_post_deallocate_pd_t        post_deallocate_pd;\r
2790 \r
2791         /*\r
2792          * Address Vector Management Verbs\r
2793          */\r
2794 \r
2795         uvp_pre_create_av                       pre_create_av;\r
2796         uvp_post_create_av_t            post_create_av;\r
2797 \r
2798         uvp_pre_query_av                        pre_query_av;\r
2799         uvp_post_query_av_t                     post_query_av;\r
2800 \r
2801         uvp_pre_modify_av                       pre_modify_av;\r
2802         uvp_post_modify_av_t            post_modify_av;\r
2803         uvp_pre_destroy_av                      pre_destroy_av;\r
2804         uvp_post_destroy_av_t           post_destroy_av;\r
2805 \r
2806         /*\r
2807          * QP Management Verbs\r
2808          */\r
2809         uvp_pre_create_qp                       pre_create_qp;\r
2810         uvp_post_create_qp_t            post_create_qp;\r
2811 \r
2812         /* No support for create_spl_qp, UAL will return error */\r
2813 \r
2814         uvp_pre_modify_qp                       pre_modify_qp;\r
2815         uvp_post_modify_qp_t            post_modify_qp;\r
2816 \r
2817         uvp_pre_query_qp                        pre_query_qp;\r
2818         uvp_post_query_qp_t                     post_query_qp;\r
2819 \r
2820         uvp_pre_destroy_qp                      pre_destroy_qp;\r
2821         uvp_post_destroy_qp_t           post_destroy_qp;\r
2822 \r
2823         /*\r
2824          * Completion Queue Management Verbs\r
2825          */\r
2826         uvp_pre_create_cq                       pre_create_cq;\r
2827         uvp_post_create_cq_t            post_create_cq;\r
2828 \r
2829         uvp_pre_query_cq                        pre_query_cq;\r
2830         uvp_post_query_cq_t                     post_query_cq;\r
2831 \r
2832         uvp_pre_resize_cq                       pre_resize_cq;\r
2833         uvp_post_resize_cq_t            post_resize_cq;\r
2834 \r
2835         uvp_pre_destroy_cq                      pre_destroy_cq;\r
2836         uvp_post_destroy_cq_t           post_destroy_cq;\r
2837 \r
2838         /*\r
2839          * Memory Window Verbs\r
2840          */\r
2841         uvp_pre_create_mw                       pre_create_mw;\r
2842         uvp_post_create_mw_t            post_create_mw;\r
2843         uvp_pre_query_mw                        pre_query_mw;\r
2844         uvp_post_query_mw_t                     post_query_mw;\r
2845         uvp_pre_destroy_mw                      pre_destroy_mw;\r
2846         uvp_post_destroy_mw_t           post_destroy_mw;\r
2847 \r
2848         /* No pre/post functions for bind */\r
2849         uvp_bind_mw                                     bind_mw;\r
2850 \r
2851         /*\r
2852          * Work Request Processing Verbs\r
2853          * Should the types be same as Verbs?\r
2854          */\r
2855         uvp_post_send                           post_send;\r
2856         uvp_post_recv                           post_recv;\r
2857 \r
2858         /*\r
2859          * Completion Processing and\r
2860          * Completion Notification Request Verbs.\r
2861          * Should the types be same as Verbs?\r
2862          */\r
2863         uvp_peek_cq                                     peek_cq;\r
2864         uvp_poll_cq                                     poll_cq;\r
2865         uvp_rearm_cq                            rearm_cq;\r
2866         uvp_rearm_n_cq                          rearm_n_cq;\r
2867 \r
2868         /*\r
2869          * Multicast Support Verbs\r
2870          */\r
2871         uvp_pre_attach_mcast            pre_attach_mcast;\r
2872         uvp_post_attach_mcast_t         post_attach_mcast;\r
2873         uvp_pre_detach_mcast            pre_detach_mcast;\r
2874         uvp_post_detach_mcast_t         post_detach_mcast;\r
2875 \r
2876 } uvp_interface_t;\r
2877 \r
2878 /********/\r
2879 \r
2880 /****f* user-mode Verbs/uvp_get_interface\r
2881 * NAME\r
2882 *       uvp_get_interface -- Get the Vendor's supported Verbs calls\r
2883 *\r
2884 * SYNOPSIS\r
2885 */\r
2886 typedef ib_api_status_t\r
2887 (AL_API *uvp_get_interface_t)(\r
2888         IN      OUT                     uvp_interface_t*        const   p_uvp );\r
2889 /*\r
2890 * DESCRIPTION\r
2891 *       This routine is called by UAL to get the functions supported by\r
2892 *       a vendor's library. Upon discovering a new CA, UAL will look for\r
2893 *       the appropriate vendor library, load the library and query using\r
2894 *       this function to get the supported interfaces.\r
2895 *\r
2896 *       If the vendor does not support an interface function, it should be\r
2897 *       set to NULL in the interface structure returned.\r
2898 *\r
2899 * PARAMETERS\r
2900 *       p_uvp\r
2901 *               [in out] Pointer to the uvp_interface_t structure that has the function\r
2902 *               vector to support verbs functionality.\r
2903 *\r
2904 * RETURN VALUE\r
2905 *       IB_SUCCESS\r
2906 *               The registration is successful.\r
2907 *       IB_INSUFFICIENT_MEMORY\r
2908 *               Insufficient memory to satisfy request\r
2909 *\r
2910 * PORTABILITY\r
2911 *       User mode\r
2912 *\r
2913 * SEE ALSO\r
2914 *       uvp_interface_t\r
2915 *\r
2916 ********/\r
2917 \r
2918 /********/\r
2919 \r
2920 #endif // __IB_UAL_UVP_H__\r