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