Dr Andrew Scott G7VAV

My photo
 
June 2025
Mo Tu We Th Fr Sa Su
26 27 28 29 30 31 1
2 3 4 5 6 7 8
9 10 11 12 13 14 15
16 17 18 19 20 21 22
23 24 25 26 27 28 29
30 1 2 3 4 5 6


ib_user_verbs.h
001: /*
002:  * Copyright (c) 2005 Topspin Communications.  All rights reserved.
003:  * Copyright (c) 2005, 2006 Cisco Systems.  All rights reserved.
004:  * Copyright (c) 2005 PathScale, Inc.  All rights reserved.
005:  * Copyright (c) 2006 Mellanox Technologies.  All rights reserved.
006:  *
007:  * This software is available to you under a choice of one of two
008:  * licenses.  You may choose to be licensed under the terms of the GNU
009:  * General Public License (GPL) Version 2, available from the file
010:  * COPYING in the main directory of this source tree, or the
011:  * OpenIB.org BSD license below:
012:  *
013:  *     Redistribution and use in source and binary forms, with or
014:  *     without modification, are permitted provided that the following
015:  *     conditions are met:
016:  *
017:  *      - Redistributions of source code must retain the above
018:  *        copyright notice, this list of conditions and the following
019:  *        disclaimer.
020:  *
021:  *      - Redistributions in binary form must reproduce the above
022:  *        copyright notice, this list of conditions and the following
023:  *        disclaimer in the documentation and/or other materials
024:  *        provided with the distribution.
025:  *
026:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
027:  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
028:  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
029:  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
030:  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
031:  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
032:  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
033:  * SOFTWARE.
034:  */
035: 
036: #ifndef IB_USER_VERBS_H
037: #define IB_USER_VERBS_H
038: 
039: #include <linux/types.h>
040: 
041: /*
042:  * Increment this value if any changes that break userspace ABI
043:  * compatibility are made.
044:  */
045: #define IB_USER_VERBS_ABI_VERSION       6
046: 
047: enum {
048:         IB_USER_VERBS_CMD_GET_CONTEXT,
049:         IB_USER_VERBS_CMD_QUERY_DEVICE,
050:         IB_USER_VERBS_CMD_QUERY_PORT,
051:         IB_USER_VERBS_CMD_ALLOC_PD,
052:         IB_USER_VERBS_CMD_DEALLOC_PD,
053:         IB_USER_VERBS_CMD_CREATE_AH,
054:         IB_USER_VERBS_CMD_MODIFY_AH,
055:         IB_USER_VERBS_CMD_QUERY_AH,
056:         IB_USER_VERBS_CMD_DESTROY_AH,
057:         IB_USER_VERBS_CMD_REG_MR,
058:         IB_USER_VERBS_CMD_REG_SMR,
059:         IB_USER_VERBS_CMD_REREG_MR,
060:         IB_USER_VERBS_CMD_QUERY_MR,
061:         IB_USER_VERBS_CMD_DEREG_MR,
062:         IB_USER_VERBS_CMD_ALLOC_MW,
063:         IB_USER_VERBS_CMD_BIND_MW,
064:         IB_USER_VERBS_CMD_DEALLOC_MW,
065:         IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL,
066:         IB_USER_VERBS_CMD_CREATE_CQ,
067:         IB_USER_VERBS_CMD_RESIZE_CQ,
068:         IB_USER_VERBS_CMD_DESTROY_CQ,
069:         IB_USER_VERBS_CMD_POLL_CQ,
070:         IB_USER_VERBS_CMD_PEEK_CQ,
071:         IB_USER_VERBS_CMD_REQ_NOTIFY_CQ,
072:         IB_USER_VERBS_CMD_CREATE_QP,
073:         IB_USER_VERBS_CMD_QUERY_QP,
074:         IB_USER_VERBS_CMD_MODIFY_QP,
075:         IB_USER_VERBS_CMD_DESTROY_QP,
076:         IB_USER_VERBS_CMD_POST_SEND,
077:         IB_USER_VERBS_CMD_POST_RECV,
078:         IB_USER_VERBS_CMD_ATTACH_MCAST,
079:         IB_USER_VERBS_CMD_DETACH_MCAST,
080:         IB_USER_VERBS_CMD_CREATE_SRQ,
081:         IB_USER_VERBS_CMD_MODIFY_SRQ,
082:         IB_USER_VERBS_CMD_QUERY_SRQ,
083:         IB_USER_VERBS_CMD_DESTROY_SRQ,
084:         IB_USER_VERBS_CMD_POST_SRQ_RECV,
085:         IB_USER_VERBS_CMD_OPEN_XRCD,
086:         IB_USER_VERBS_CMD_CLOSE_XRCD,
087:         IB_USER_VERBS_CMD_CREATE_XSRQ,
088:         IB_USER_VERBS_CMD_OPEN_QP
089: };
090: 
091: /*
092:  * Make sure that all structs defined in this file remain laid out so
093:  * that they pack the same way on 32-bit and 64-bit architectures (to
094:  * avoid incompatibility between 32-bit userspace and 64-bit kernels).
095:  * Specifically:
096:  *  - Do not use pointer types -- pass pointers in __u64 instead.
097:  *  - Make sure that any structure larger than 4 bytes is padded to a
098:  *    multiple of 8 bytes.  Otherwise the structure size will be
099:  *    different between 32-bit and 64-bit architectures.
100:  */
101: 
102: struct ib_uverbs_async_event_desc {
103:         __u64 element;
104:         __u32 event_type;       /* enum ib_event_type */
105:         __u32 reserved;
106: };
107: 
108: struct ib_uverbs_comp_event_desc {
109:         __u64 cq_handle;
110: };
111: 
112: /*
113:  * All commands from userspace should start with a __u32 command field
114:  * followed by __u16 in_words and out_words fields (which give the
115:  * length of the command block and response buffer if any in 32-bit
116:  * words).  The kernel driver will read these fields first and read
117:  * the rest of the command struct based on these value.
118:  */
119: 
120: struct ib_uverbs_cmd_hdr {
121:         __u32 command;
122:         __u16 in_words;
123:         __u16 out_words;
124: };
125: 
126: struct ib_uverbs_get_context {
127:         __u64 response;
128:         __u64 driver_data[0];
129: };
130: 
131: struct ib_uverbs_get_context_resp {
132:         __u32 async_fd;
133:         __u32 num_comp_vectors;
134: };
135: 
136: struct ib_uverbs_query_device {
137:         __u64 response;
138:         __u64 driver_data[0];
139: };
140: 
141: struct ib_uverbs_query_device_resp {
142:         __u64 fw_ver;
143:         __be64 node_guid;
144:         __be64 sys_image_guid;
145:         __u64 max_mr_size;
146:         __u64 page_size_cap;
147:         __u32 vendor_id;
148:         __u32 vendor_part_id;
149:         __u32 hw_ver;
150:         __u32 max_qp;
151:         __u32 max_qp_wr;
152:         __u32 device_cap_flags;
153:         __u32 max_sge;
154:         __u32 max_sge_rd;
155:         __u32 max_cq;
156:         __u32 max_cqe;
157:         __u32 max_mr;
158:         __u32 max_pd;
159:         __u32 max_qp_rd_atom;
160:         __u32 max_ee_rd_atom;
161:         __u32 max_res_rd_atom;
162:         __u32 max_qp_init_rd_atom;
163:         __u32 max_ee_init_rd_atom;
164:         __u32 atomic_cap;
165:         __u32 max_ee;
166:         __u32 max_rdd;
167:         __u32 max_mw;
168:         __u32 max_raw_ipv6_qp;
169:         __u32 max_raw_ethy_qp;
170:         __u32 max_mcast_grp;
171:         __u32 max_mcast_qp_attach;
172:         __u32 max_total_mcast_qp_attach;
173:         __u32 max_ah;
174:         __u32 max_fmr;
175:         __u32 max_map_per_fmr;
176:         __u32 max_srq;
177:         __u32 max_srq_wr;
178:         __u32 max_srq_sge;
179:         __u16 max_pkeys;
180:         __u8  local_ca_ack_delay;
181:         __u8  phys_port_cnt;
182:         __u8  reserved[4];
183: };
184: 
185: struct ib_uverbs_query_port {
186:         __u64 response;
187:         __u8  port_num;
188:         __u8  reserved[7];
189:         __u64 driver_data[0];
190: };
191: 
192: struct ib_uverbs_query_port_resp {
193:         __u32 port_cap_flags;
194:         __u32 max_msg_sz;
195:         __u32 bad_pkey_cntr;
196:         __u32 qkey_viol_cntr;
197:         __u32 gid_tbl_len;
198:         __u16 pkey_tbl_len;
199:         __u16 lid;
200:         __u16 sm_lid;
201:         __u8  state;
202:         __u8  max_mtu;
203:         __u8  active_mtu;
204:         __u8  lmc;
205:         __u8  max_vl_num;
206:         __u8  sm_sl;
207:         __u8  subnet_timeout;
208:         __u8  init_type_reply;
209:         __u8  active_width;
210:         __u8  active_speed;
211:         __u8  phys_state;
212:         __u8  link_layer;
213:         __u8  reserved[2];
214: };
215: 
216: struct ib_uverbs_alloc_pd {
217:         __u64 response;
218:         __u64 driver_data[0];
219: };
220: 
221: struct ib_uverbs_alloc_pd_resp {
222:         __u32 pd_handle;
223: };
224: 
225: struct ib_uverbs_dealloc_pd {
226:         __u32 pd_handle;
227: };
228: 
229: struct ib_uverbs_open_xrcd {
230:         __u64 response;
231:         __u32 fd;
232:         __u32 oflags;
233:         __u64 driver_data[0];
234: };
235: 
236: struct ib_uverbs_open_xrcd_resp {
237:         __u32 xrcd_handle;
238: };
239: 
240: struct ib_uverbs_close_xrcd {
241:         __u32 xrcd_handle;
242: };
243: 
244: struct ib_uverbs_reg_mr {
245:         __u64 response;
246:         __u64 start;
247:         __u64 length;
248:         __u64 hca_va;
249:         __u32 pd_handle;
250:         __u32 access_flags;
251:         __u64 driver_data[0];
252: };
253: 
254: struct ib_uverbs_reg_mr_resp {
255:         __u32 mr_handle;
256:         __u32 lkey;
257:         __u32 rkey;
258: };
259: 
260: struct ib_uverbs_dereg_mr {
261:         __u32 mr_handle;
262: };
263: 
264: struct ib_uverbs_create_comp_channel {
265:         __u64 response;
266: };
267: 
268: struct ib_uverbs_create_comp_channel_resp {
269:         __u32 fd;
270: };
271: 
272: struct ib_uverbs_create_cq {
273:         __u64 response;
274:         __u64 user_handle;
275:         __u32 cqe;
276:         __u32 comp_vector;
277:         __s32 comp_channel;
278:         __u32 reserved;
279:         __u64 driver_data[0];
280: };
281: 
282: struct ib_uverbs_create_cq_resp {
283:         __u32 cq_handle;
284:         __u32 cqe;
285: };
286: 
287: struct ib_uverbs_resize_cq {
288:         __u64 response;
289:         __u32 cq_handle;
290:         __u32 cqe;
291:         __u64 driver_data[0];
292: };
293: 
294: struct ib_uverbs_resize_cq_resp {
295:         __u32 cqe;
296:         __u32 reserved;
297:         __u64 driver_data[0];
298: };
299: 
300: struct ib_uverbs_poll_cq {
301:         __u64 response;
302:         __u32 cq_handle;
303:         __u32 ne;
304: };
305: 
306: struct ib_uverbs_wc {
307:         __u64 wr_id;
308:         __u32 status;
309:         __u32 opcode;
310:         __u32 vendor_err;
311:         __u32 byte_len;
312:         union {
313:                 __u32 imm_data;
314:                 __u32 invalidate_rkey;
315:         } ex;
316:         __u32 qp_num;
317:         __u32 src_qp;
318:         __u32 wc_flags;
319:         __u16 pkey_index;
320:         __u16 slid;
321:         __u8 sl;
322:         __u8 dlid_path_bits;
323:         __u8 port_num;
324:         __u8 reserved;
325: };
326: 
327: struct ib_uverbs_poll_cq_resp {
328:         __u32 count;
329:         __u32 reserved;
330:         struct ib_uverbs_wc wc[0];
331: };
332: 
333: struct ib_uverbs_req_notify_cq {
334:         __u32 cq_handle;
335:         __u32 solicited_only;
336: };
337: 
338: struct ib_uverbs_destroy_cq {
339:         __u64 response;
340:         __u32 cq_handle;
341:         __u32 reserved;
342: };
343: 
344: struct ib_uverbs_destroy_cq_resp {
345:         __u32 comp_events_reported;
346:         __u32 async_events_reported;
347: };
348: 
349: struct ib_uverbs_global_route {
350:         __u8  dgid[16];
351:         __u32 flow_label;
352:         __u8  sgid_index;
353:         __u8  hop_limit;
354:         __u8  traffic_class;
355:         __u8  reserved;
356: };
357: 
358: struct ib_uverbs_ah_attr {
359:         struct ib_uverbs_global_route grh;
360:         __u16 dlid;
361:         __u8  sl;
362:         __u8  src_path_bits;
363:         __u8  static_rate;
364:         __u8  is_global;
365:         __u8  port_num;
366:         __u8  reserved;
367: };
368: 
369: struct ib_uverbs_qp_attr {
370:         __u32   qp_attr_mask;
371:         __u32   qp_state;
372:         __u32   cur_qp_state;
373:         __u32   path_mtu;
374:         __u32   path_mig_state;
375:         __u32   qkey;
376:         __u32   rq_psn;
377:         __u32   sq_psn;
378:         __u32   dest_qp_num;
379:         __u32   qp_access_flags;
380: 
381:         struct ib_uverbs_ah_attr ah_attr;
382:         struct ib_uverbs_ah_attr alt_ah_attr;
383: 
384:         /* ib_qp_cap */
385:         __u32   max_send_wr;
386:         __u32   max_recv_wr;
387:         __u32   max_send_sge;
388:         __u32   max_recv_sge;
389:         __u32   max_inline_data;
390: 
391:         __u16   pkey_index;
392:         __u16   alt_pkey_index;
393:         __u8    en_sqd_async_notify;
394:         __u8    sq_draining;
395:         __u8    max_rd_atomic;
396:         __u8    max_dest_rd_atomic;
397:         __u8    min_rnr_timer;
398:         __u8    port_num;
399:         __u8    timeout;
400:         __u8    retry_cnt;
401:         __u8    rnr_retry;
402:         __u8    alt_port_num;
403:         __u8    alt_timeout;
404:         __u8    reserved[5];
405: };
406: 
407: struct ib_uverbs_create_qp {
408:         __u64 response;
409:         __u64 user_handle;
410:         __u32 pd_handle;
411:         __u32 send_cq_handle;
412:         __u32 recv_cq_handle;
413:         __u32 srq_handle;
414:         __u32 max_send_wr;
415:         __u32 max_recv_wr;
416:         __u32 max_send_sge;
417:         __u32 max_recv_sge;
418:         __u32 max_inline_data;
419:         __u8  sq_sig_all;
420:         __u8  qp_type;
421:         __u8  is_srq;
422:         __u8  reserved;
423:         __u64 driver_data[0];
424: };
425: 
426: struct ib_uverbs_open_qp {
427:         __u64 response;
428:         __u64 user_handle;
429:         __u32 pd_handle;
430:         __u32 qpn;
431:         __u8  qp_type;
432:         __u8  reserved[7];
433:         __u64 driver_data[0];
434: };
435: 
436: /* also used for open response */
437: struct ib_uverbs_create_qp_resp {
438:         __u32 qp_handle;
439:         __u32 qpn;
440:         __u32 max_send_wr;
441:         __u32 max_recv_wr;
442:         __u32 max_send_sge;
443:         __u32 max_recv_sge;
444:         __u32 max_inline_data;
445:         __u32 reserved;
446: };
447: 
448: /*
449:  * This struct needs to remain a multiple of 8 bytes to keep the
450:  * alignment of the modify QP parameters.
451:  */
452: struct ib_uverbs_qp_dest {
453:         __u8  dgid[16];
454:         __u32 flow_label;
455:         __u16 dlid;
456:         __u16 reserved;
457:         __u8  sgid_index;
458:         __u8  hop_limit;
459:         __u8  traffic_class;
460:         __u8  sl;
461:         __u8  src_path_bits;
462:         __u8  static_rate;
463:         __u8  is_global;
464:         __u8  port_num;
465: };
466: 
467: struct ib_uverbs_query_qp {
468:         __u64 response;
469:         __u32 qp_handle;
470:         __u32 attr_mask;
471:         __u64 driver_data[0];
472: };
473: 
474: struct ib_uverbs_query_qp_resp {
475:         struct ib_uverbs_qp_dest dest;
476:         struct ib_uverbs_qp_dest alt_dest;
477:         __u32 max_send_wr;
478:         __u32 max_recv_wr;
479:         __u32 max_send_sge;
480:         __u32 max_recv_sge;
481:         __u32 max_inline_data;
482:         __u32 qkey;
483:         __u32 rq_psn;
484:         __u32 sq_psn;
485:         __u32 dest_qp_num;
486:         __u32 qp_access_flags;
487:         __u16 pkey_index;
488:         __u16 alt_pkey_index;
489:         __u8  qp_state;
490:         __u8  cur_qp_state;
491:         __u8  path_mtu;
492:         __u8  path_mig_state;
493:         __u8  sq_draining;
494:         __u8  max_rd_atomic;
495:         __u8  max_dest_rd_atomic;
496:         __u8  min_rnr_timer;
497:         __u8  port_num;
498:         __u8  timeout;
499:         __u8  retry_cnt;
500:         __u8  rnr_retry;
501:         __u8  alt_port_num;
502:         __u8  alt_timeout;
503:         __u8  sq_sig_all;
504:         __u8  reserved[5];
505:         __u64 driver_data[0];
506: };
507: 
508: struct ib_uverbs_modify_qp {
509:         struct ib_uverbs_qp_dest dest;
510:         struct ib_uverbs_qp_dest alt_dest;
511:         __u32 qp_handle;
512:         __u32 attr_mask;
513:         __u32 qkey;
514:         __u32 rq_psn;
515:         __u32 sq_psn;
516:         __u32 dest_qp_num;
517:         __u32 qp_access_flags;
518:         __u16 pkey_index;
519:         __u16 alt_pkey_index;
520:         __u8  qp_state;
521:         __u8  cur_qp_state;
522:         __u8  path_mtu;
523:         __u8  path_mig_state;
524:         __u8  en_sqd_async_notify;
525:         __u8  max_rd_atomic;
526:         __u8  max_dest_rd_atomic;
527:         __u8  min_rnr_timer;
528:         __u8  port_num;
529:         __u8  timeout;
530:         __u8  retry_cnt;
531:         __u8  rnr_retry;
532:         __u8  alt_port_num;
533:         __u8  alt_timeout;
534:         __u8  reserved[2];
535:         __u64 driver_data[0];
536: };
537: 
538: struct ib_uverbs_modify_qp_resp {
539: };
540: 
541: struct ib_uverbs_destroy_qp {
542:         __u64 response;
543:         __u32 qp_handle;
544:         __u32 reserved;
545: };
546: 
547: struct ib_uverbs_destroy_qp_resp {
548:         __u32 events_reported;
549: };
550: 
551: /*
552:  * The ib_uverbs_sge structure isn't used anywhere, since we assume
553:  * the ib_sge structure is packed the same way on 32-bit and 64-bit
554:  * architectures in both kernel and user space.  It's just here to
555:  * document the ABI.
556:  */
557: struct ib_uverbs_sge {
558:         __u64 addr;
559:         __u32 length;
560:         __u32 lkey;
561: };
562: 
563: struct ib_uverbs_send_wr {
564:         __u64 wr_id;
565:         __u32 num_sge;
566:         __u32 opcode;
567:         __u32 send_flags;
568:         union {
569:                 __u32 imm_data;
570:                 __u32 invalidate_rkey;
571:         } ex;
572:         union {
573:                 struct {
574:                         __u64 remote_addr;
575:                         __u32 rkey;
576:                         __u32 reserved;
577:                 } rdma;
578:                 struct {
579:                         __u64 remote_addr;
580:                         __u64 compare_add;
581:                         __u64 swap;
582:                         __u32 rkey;
583:                         __u32 reserved;
584:                 } atomic;
585:                 struct {
586:                         __u32 ah;
587:                         __u32 remote_qpn;
588:                         __u32 remote_qkey;
589:                         __u32 reserved;
590:                 } ud;
591:         } wr;
592: };
593: 
594: struct ib_uverbs_post_send {
595:         __u64 response;
596:         __u32 qp_handle;
597:         __u32 wr_count;
598:         __u32 sge_count;
599:         __u32 wqe_size;
600:         struct ib_uverbs_send_wr send_wr[0];
601: };
602: 
603: struct ib_uverbs_post_send_resp {
604:         __u32 bad_wr;
605: };
606: 
607: struct ib_uverbs_recv_wr {
608:         __u64 wr_id;
609:         __u32 num_sge;
610:         __u32 reserved;
611: };
612: 
613: struct ib_uverbs_post_recv {
614:         __u64 response;
615:         __u32 qp_handle;
616:         __u32 wr_count;
617:         __u32 sge_count;
618:         __u32 wqe_size;
619:         struct ib_uverbs_recv_wr recv_wr[0];
620: };
621: 
622: struct ib_uverbs_post_recv_resp {
623:         __u32 bad_wr;
624: };
625: 
626: struct ib_uverbs_post_srq_recv {
627:         __u64 response;
628:         __u32 srq_handle;
629:         __u32 wr_count;
630:         __u32 sge_count;
631:         __u32 wqe_size;
632:         struct ib_uverbs_recv_wr recv[0];
633: };
634: 
635: struct ib_uverbs_post_srq_recv_resp {
636:         __u32 bad_wr;
637: };
638: 
639: struct ib_uverbs_create_ah {
640:         __u64 response;
641:         __u64 user_handle;
642:         __u32 pd_handle;
643:         __u32 reserved;
644:         struct ib_uverbs_ah_attr attr;
645: };
646: 
647: struct ib_uverbs_create_ah_resp {
648:         __u32 ah_handle;
649: };
650: 
651: struct ib_uverbs_destroy_ah {
652:         __u32 ah_handle;
653: };
654: 
655: struct ib_uverbs_attach_mcast {
656:         __u8  gid[16];
657:         __u32 qp_handle;
658:         __u16 mlid;
659:         __u16 reserved;
660:         __u64 driver_data[0];
661: };
662: 
663: struct ib_uverbs_detach_mcast {
664:         __u8  gid[16];
665:         __u32 qp_handle;
666:         __u16 mlid;
667:         __u16 reserved;
668:         __u64 driver_data[0];
669: };
670: 
671: struct ib_uverbs_create_srq {
672:         __u64 response;
673:         __u64 user_handle;
674:         __u32 pd_handle;
675:         __u32 max_wr;
676:         __u32 max_sge;
677:         __u32 srq_limit;
678:         __u64 driver_data[0];
679: };
680: 
681: struct ib_uverbs_create_xsrq {
682:         __u64 response;
683:         __u64 user_handle;
684:         __u32 srq_type;
685:         __u32 pd_handle;
686:         __u32 max_wr;
687:         __u32 max_sge;
688:         __u32 srq_limit;
689:         __u32 reserved;
690:         __u32 xrcd_handle;
691:         __u32 cq_handle;
692:         __u64 driver_data[0];
693: };
694: 
695: struct ib_uverbs_create_srq_resp {
696:         __u32 srq_handle;
697:         __u32 max_wr;
698:         __u32 max_sge;
699:         __u32 srqn;
700: };
701: 
702: struct ib_uverbs_modify_srq {
703:         __u32 srq_handle;
704:         __u32 attr_mask;
705:         __u32 max_wr;
706:         __u32 srq_limit;
707:         __u64 driver_data[0];
708: };
709: 
710: struct ib_uverbs_query_srq {
711:         __u64 response;
712:         __u32 srq_handle;
713:         __u32 reserved;
714:         __u64 driver_data[0];
715: };
716: 
717: struct ib_uverbs_query_srq_resp {
718:         __u32 max_wr;
719:         __u32 max_sge;
720:         __u32 srq_limit;
721:         __u32 reserved;
722: };
723: 
724: struct ib_uverbs_destroy_srq {
725:         __u64 response;
726:         __u32 srq_handle;
727:         __u32 reserved;
728: };
729: 
730: struct ib_uverbs_destroy_srq_resp {
731:         __u32 events_reported;
732: };
733: 
734: #endif /* IB_USER_VERBS_H */
735: 


for client (none)
© Andrew Scott 2006 - 2025,
All Rights Reserved
http://www.andrew-scott.uk/
Andrew Scott
http://www.andrew-scott.co.uk/