/* * ibv_wc_status_str */ typedef struct { // Parameters: enum ibv_wc_status status; // Return value: const char * ret; } __attribute__((packed)) uhyve_ibv_wc_status_str_t; const char * ibv_wc_status_str(enum ibv_wc_status status) { uhyve_ibv_wc_status_str_t uhyve_args; uhyve_args.status = status; uhyve_send(UHYVE_PORT_IBV_WC_STATUS_STR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_rate_to_mult */ typedef struct { // Parameters: enum ibv_rate rate; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_rate_to_mult_t; int ibv_rate_to_mult(enum ibv_rate rate) { uhyve_ibv_rate_to_mult_t uhyve_args; uhyve_args.rate = rate; uhyve_send(UHYVE_PORT_IBV_RATE_TO_MULT, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * mult_to_ibv_rate */ typedef struct { // Parameters: int mult; // Return value: enum ibv_rate ret; } __attribute__((packed)) uhyve_mult_to_ibv_rate_t; enum ibv_rate mult_to_ibv_rate(int mult) { uhyve_mult_to_ibv_rate_t uhyve_args; uhyve_args.mult = mult; uhyve_send(UHYVE_PORT_MULT_TO_IBV_RATE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_rate_to_mbps */ typedef struct { // Parameters: enum ibv_rate rate; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_rate_to_mbps_t; int ibv_rate_to_mbps(enum ibv_rate rate) { uhyve_ibv_rate_to_mbps_t uhyve_args; uhyve_args.rate = rate; uhyve_send(UHYVE_PORT_IBV_RATE_TO_MBPS, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * mbps_to_ibv_rate */ typedef struct { // Parameters: int mbps; // Return value: enum ibv_rate ret; } __attribute__((packed)) uhyve_mbps_to_ibv_rate_t; enum ibv_rate mbps_to_ibv_rate(int mbps) { uhyve_mbps_to_ibv_rate_t uhyve_args; uhyve_args.mbps = mbps; uhyve_send(UHYVE_PORT_MBPS_TO_IBV_RATE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_cq_ex_to_cq */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: struct ibv_cq * ret; } __attribute__((packed)) uhyve_ibv_cq_ex_to_cq_t; struct ibv_cq * ibv_cq_ex_to_cq(struct ibv_cq_ex * cq) { uhyve_ibv_cq_ex_to_cq_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_CQ_EX_TO_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_start_poll */ typedef struct { // Parameters: struct ibv_cq_ex * cq; struct ibv_poll_cq_attr * attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_start_poll_t; int ibv_start_poll(struct ibv_cq_ex * cq, struct ibv_poll_cq_attr * attr) { uhyve_ibv_start_poll_t uhyve_args; uhyve_args.cq = cq; uhyve_args.attr = (struct ibv_poll_cq_attr *) guest_to_host((size_t) attr); uhyve_send(UHYVE_PORT_IBV_START_POLL, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_next_poll */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_next_poll_t; int ibv_next_poll(struct ibv_cq_ex * cq) { uhyve_ibv_next_poll_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_NEXT_POLL, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_end_poll */ typedef struct { // Parameters: struct ibv_cq_ex * cq; } __attribute__((packed)) uhyve_ibv_end_poll_t; void ibv_end_poll(struct ibv_cq_ex * cq) { uhyve_ibv_end_poll_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_END_POLL, (unsigned) virt_to_phys((size_t) &uhyve_args)); } /* * ibv_wc_read_opcode */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: enum ibv_wc_opcode ret; } __attribute__((packed)) uhyve_ibv_wc_read_opcode_t; enum ibv_wc_opcode ibv_wc_read_opcode(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_opcode_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_OPCODE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_vendor_err */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_vendor_err_t; uint32_t ibv_wc_read_vendor_err(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_vendor_err_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_VENDOR_ERR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_byte_len */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_byte_len_t; uint32_t ibv_wc_read_byte_len(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_byte_len_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_BYTE_LEN, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_imm_data */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: __be32 ret; } __attribute__((packed)) uhyve_ibv_wc_read_imm_data_t; __be32 ibv_wc_read_imm_data(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_imm_data_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_IMM_DATA, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_invalidated_rkey */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_invalidated_rkey_t; uint32_t ibv_wc_read_invalidated_rkey(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_invalidated_rkey_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_INVALIDATED_RKEY, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_qp_num */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_qp_num_t; uint32_t ibv_wc_read_qp_num(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_qp_num_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_QP_NUM, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_src_qp */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_src_qp_t; uint32_t ibv_wc_read_src_qp(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_src_qp_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_SRC_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_wc_flags */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_wc_read_wc_flags_t; int ibv_wc_read_wc_flags(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_wc_flags_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_WC_FLAGS, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_slid */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_slid_t; uint32_t ibv_wc_read_slid(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_slid_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_SLID, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_sl */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint8_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_sl_t; uint8_t ibv_wc_read_sl(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_sl_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_SL, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_dlid_path_bits */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint8_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_dlid_path_bits_t; uint8_t ibv_wc_read_dlid_path_bits(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_dlid_path_bits_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_DLID_PATH_BITS, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_completion_ts */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint64_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_completion_ts_t; uint64_t ibv_wc_read_completion_ts(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_completion_ts_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_COMPLETION_TS, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_cvlan */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint16_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_cvlan_t; uint16_t ibv_wc_read_cvlan(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_cvlan_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_CVLAN, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_wc_read_flow_tag */ typedef struct { // Parameters: struct ibv_cq_ex * cq; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_wc_read_flow_tag_t; uint32_t ibv_wc_read_flow_tag(struct ibv_cq_ex * cq) { uhyve_ibv_wc_read_flow_tag_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_WC_READ_FLOW_TAG, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_post_wq_recv */ typedef struct { // Parameters: struct ibv_wq * wq; struct ibv_recv_wr * recv_wr; struct ibv_recv_wr ** bad_recv_wr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_post_wq_recv_t; int ibv_post_wq_recv(struct ibv_wq * wq, struct ibv_recv_wr * recv_wr, struct ibv_recv_wr ** bad_recv_wr) { uhyve_ibv_post_wq_recv_t uhyve_args; uhyve_args.wq = wq; uhyve_args.recv_wr = (struct ibv_recv_wr *) guest_to_host((size_t) recv_wr); uhyve_args.bad_recv_wr = (struct ibv_recv_wr **) guest_to_host((size_t) bad_recv_wr); // TODO: Check ** param here. struct ibv_recv_wr * curr_wr; int num_sges_max; int num_wrs; // Number of work requests in linked list and SGEs in each WR num_wrs = 0; num_sges_max = 0; for (curr_wr = recv_wr; curr_wr; curr_wr = curr_wr->next) { num_wrs++; if (num_sges_max < curr_wr->num_sge) { num_sges_max = curr_wr->num_sge; } } // Backup arrays for original guest memory pointers struct ibv_recv_wr * wr__next [num_wrs]; struct ibv_sge * wr__sg_list [num_wrs]; uint64_t wr__sg_list__addr[num_wrs][num_sges_max]; curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { // Next pointer wr__next[w] = curr_wr->next; curr_wr->next = (struct ibv_recv_wr *) guest_to_host((size_t) curr_wr->next); // SGE array for (int s = 0; s < curr_wr->num_sge; s++) { wr__sg_list__addr[w][s] = curr_wr->sg_list[s].addr; curr_wr->sg_list[s].addr = (uint64_t) guest_to_host((size_t) curr_wr->sg_list[s].addr); } wr__sg_list[w] = curr_wr->sg_list; curr_wr->sg_list = (struct ibv_sge *) guest_to_host((size_t) curr_wr->sg_list); curr_wr = wr__next[w]; } uhyve_send(UHYVE_PORT_IBV_POST_WQ_RECV, (unsigned) virt_to_phys((size_t) &uhyve_args)); if (*bad_recv_wr && *bad_recv_wr == uhyve_args.recv_wr) { *bad_recv_wr = recv_wr; } curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { if (*bad_recv_wr && *bad_recv_wr == curr_wr->next) { *bad_recv_wr = wr__next[w]; } curr_wr->next = wr__next[w]; curr_wr->sg_list = wr__sg_list[w]; for (int s = 0; s < curr_wr->num_sge; s++) { curr_wr->sg_list[s].addr = wr__sg_list__addr[w][s]; } curr_wr = curr_wr->next; } return uhyve_args.ret; } /* * ibv_get_device_list */ typedef struct { // Parameters: int * num_devices; // Return value: struct ibv_device ** ret; } __attribute__((packed)) uhyve_ibv_get_device_list_t; struct ibv_device ** ibv_get_device_list(int * num_devices) { uhyve_ibv_get_device_list_t uhyve_args; uhyve_args.num_devices = (int *) guest_to_host((size_t) num_devices); uhyve_send(UHYVE_PORT_IBV_GET_DEVICE_LIST, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_free_device_list */ typedef struct { // Parameters: struct ibv_device ** list; } __attribute__((packed)) uhyve_ibv_free_device_list_t; void ibv_free_device_list(struct ibv_device ** list) { uhyve_ibv_free_device_list_t uhyve_args; uhyve_args.list = list; uhyve_send(UHYVE_PORT_IBV_FREE_DEVICE_LIST, (unsigned) virt_to_phys((size_t) &uhyve_args)); } /* * ibv_get_device_name */ typedef struct { // Parameters: struct ibv_device * device; // Return value: const char * ret; } __attribute__((packed)) uhyve_ibv_get_device_name_t; const char * ibv_get_device_name(struct ibv_device * device) { uhyve_ibv_get_device_name_t uhyve_args; uhyve_args.device = device; uhyve_send(UHYVE_PORT_IBV_GET_DEVICE_NAME, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_get_device_guid */ typedef struct { // Parameters: struct ibv_device * device; // Return value: __be64 ret; } __attribute__((packed)) uhyve_ibv_get_device_guid_t; __be64 ibv_get_device_guid(struct ibv_device * device) { uhyve_ibv_get_device_guid_t uhyve_args; uhyve_args.device = device; uhyve_send(UHYVE_PORT_IBV_GET_DEVICE_GUID, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_open_device */ typedef struct { // Parameters: struct ibv_device * device; // Return value: struct ibv_context * ret; } __attribute__((packed)) uhyve_ibv_open_device_t; struct ibv_context * ibv_open_device(struct ibv_device * device) { uhyve_ibv_open_device_t uhyve_args; uhyve_args.device = device; uhyve_send(UHYVE_PORT_IBV_OPEN_DEVICE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_close_device */ typedef struct { // Parameters: struct ibv_context * context; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_close_device_t; int ibv_close_device(struct ibv_context * context) { uhyve_ibv_close_device_t uhyve_args; uhyve_args.context = context; uhyve_send(UHYVE_PORT_IBV_CLOSE_DEVICE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_get_async_event */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_async_event * event; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_get_async_event_t; int ibv_get_async_event(struct ibv_context * context, struct ibv_async_event * event) { uhyve_ibv_get_async_event_t uhyve_args; uhyve_args.context = context; uhyve_args.event = (struct ibv_async_event *) guest_to_host((size_t) event); uhyve_send(UHYVE_PORT_IBV_GET_ASYNC_EVENT, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_ack_async_event */ typedef struct { // Parameters: struct ibv_async_event * event; } __attribute__((packed)) uhyve_ibv_ack_async_event_t; void ibv_ack_async_event(struct ibv_async_event * event) { uhyve_ibv_ack_async_event_t uhyve_args; uhyve_args.event = (struct ibv_async_event *) guest_to_host((size_t) event); uhyve_send(UHYVE_PORT_IBV_ACK_ASYNC_EVENT, (unsigned) virt_to_phys((size_t) &uhyve_args)); } /* * ibv_query_device */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_device_attr * device_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_device_t; int ibv_query_device(struct ibv_context * context, struct ibv_device_attr * device_attr) { uhyve_ibv_query_device_t uhyve_args; uhyve_args.context = context; uhyve_args.device_attr = (struct ibv_device_attr *) guest_to_host((size_t) device_attr); uhyve_send(UHYVE_PORT_IBV_QUERY_DEVICE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_port */ typedef struct { // Parameters: struct ibv_context * context; uint8_t port_num; struct ibv_port_attr * port_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_port_t; int ibv_query_port(struct ibv_context * context, uint8_t port_num, struct ibv_port_attr * port_attr) { uhyve_ibv_query_port_t uhyve_args; uhyve_args.context = context; uhyve_args.port_num = port_num; uhyve_args.port_attr = (struct ibv_port_attr *) guest_to_host((size_t) port_attr); uhyve_send(UHYVE_PORT_IBV_QUERY_PORT, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_gid */ typedef struct { // Parameters: struct ibv_context * context; uint8_t port_num; int index; union ibv_gid * gid; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_gid_t; int ibv_query_gid(struct ibv_context * context, uint8_t port_num, int index, union ibv_gid * gid) { uhyve_ibv_query_gid_t uhyve_args; uhyve_args.context = context; uhyve_args.port_num = port_num; uhyve_args.index = index; uhyve_args.gid = (union ibv_gid *) guest_to_host((size_t) gid); uhyve_send(UHYVE_PORT_IBV_QUERY_GID, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_pkey */ typedef struct { // Parameters: struct ibv_context * context; uint8_t port_num; int index; __be16 * pkey; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_pkey_t; int ibv_query_pkey(struct ibv_context * context, uint8_t port_num, int index, __be16 * pkey) { uhyve_ibv_query_pkey_t uhyve_args; uhyve_args.context = context; uhyve_args.port_num = port_num; uhyve_args.index = index; uhyve_args.pkey = (__be16 *) guest_to_host((size_t) pkey); uhyve_send(UHYVE_PORT_IBV_QUERY_PKEY, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_alloc_pd */ typedef struct { // Parameters: struct ibv_context * context; // Return value: struct ibv_pd * ret; } __attribute__((packed)) uhyve_ibv_alloc_pd_t; struct ibv_pd * ibv_alloc_pd(struct ibv_context * context) { uhyve_ibv_alloc_pd_t uhyve_args; uhyve_args.context = context; uhyve_send(UHYVE_PORT_IBV_ALLOC_PD, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_dealloc_pd */ typedef struct { // Parameters: struct ibv_pd * pd; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_dealloc_pd_t; int ibv_dealloc_pd(struct ibv_pd * pd) { uhyve_ibv_dealloc_pd_t uhyve_args; uhyve_args.pd = pd; uhyve_send(UHYVE_PORT_IBV_DEALLOC_PD, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_flow */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_flow_attr * flow; // Return value: struct ibv_flow * ret; } __attribute__((packed)) uhyve_ibv_create_flow_t; struct ibv_flow * ibv_create_flow(struct ibv_qp * qp, struct ibv_flow_attr * flow) { uhyve_ibv_create_flow_t uhyve_args; uhyve_args.qp = qp; uhyve_args.flow = (struct ibv_flow_attr *) guest_to_host((size_t) flow); uhyve_send(UHYVE_PORT_IBV_CREATE_FLOW, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_flow */ typedef struct { // Parameters: struct ibv_flow * flow_id; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_flow_t; int ibv_destroy_flow(struct ibv_flow * flow_id) { uhyve_ibv_destroy_flow_t uhyve_args; uhyve_args.flow_id = flow_id; uhyve_send(UHYVE_PORT_IBV_DESTROY_FLOW, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_open_xrcd */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_xrcd_init_attr * xrcd_init_attr; // Return value: struct ibv_xrcd * ret; } __attribute__((packed)) uhyve_ibv_open_xrcd_t; struct ibv_xrcd * ibv_open_xrcd(struct ibv_context * context, struct ibv_xrcd_init_attr * xrcd_init_attr) { uhyve_ibv_open_xrcd_t uhyve_args; uhyve_args.context = context; uhyve_args.xrcd_init_attr = (struct ibv_xrcd_init_attr *) guest_to_host((size_t) xrcd_init_attr); uhyve_send(UHYVE_PORT_IBV_OPEN_XRCD, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_close_xrcd */ typedef struct { // Parameters: struct ibv_xrcd * xrcd; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_close_xrcd_t; int ibv_close_xrcd(struct ibv_xrcd * xrcd) { uhyve_ibv_close_xrcd_t uhyve_args; uhyve_args.xrcd = xrcd; uhyve_send(UHYVE_PORT_IBV_CLOSE_XRCD, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_reg_mr */ typedef struct { // Parameters: struct ibv_pd * pd; void * addr; int length; int access; // Return value: struct ibv_mr * ret; } __attribute__((packed)) uhyve_ibv_reg_mr_t; struct ibv_mr * ibv_reg_mr(struct ibv_pd * pd, void * addr, int length, int access) { uhyve_ibv_reg_mr_t uhyve_args; uhyve_args.pd = pd; uhyve_args.addr = (void *) guest_to_host((size_t) addr); uhyve_args.length = length; uhyve_args.access = access; uhyve_send(UHYVE_PORT_IBV_REG_MR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_rereg_mr */ typedef struct { // Parameters: struct ibv_mr * mr; int flags; struct ibv_pd * pd; void * addr; int length; int access; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_rereg_mr_t; int ibv_rereg_mr(struct ibv_mr * mr, int flags, struct ibv_pd * pd, void * addr, int length, int access) { uhyve_ibv_rereg_mr_t uhyve_args; uhyve_args.mr = mr; uhyve_args.flags = flags; uhyve_args.pd = pd; uhyve_args.addr = (void *) guest_to_host((size_t) addr); uhyve_args.length = length; uhyve_args.access = access; uhyve_send(UHYVE_PORT_IBV_REREG_MR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_dereg_mr */ typedef struct { // Parameters: struct ibv_mr * mr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_dereg_mr_t; int ibv_dereg_mr(struct ibv_mr * mr) { uhyve_ibv_dereg_mr_t uhyve_args; uhyve_args.mr = mr; uhyve_send(UHYVE_PORT_IBV_DEREG_MR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_alloc_mw */ typedef struct { // Parameters: struct ibv_pd * pd; enum ibv_mw_type type; // Return value: struct ibv_mw * ret; } __attribute__((packed)) uhyve_ibv_alloc_mw_t; struct ibv_mw * ibv_alloc_mw(struct ibv_pd * pd, enum ibv_mw_type type) { uhyve_ibv_alloc_mw_t uhyve_args; uhyve_args.pd = pd; uhyve_args.type = type; uhyve_send(UHYVE_PORT_IBV_ALLOC_MW, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_dealloc_mw */ typedef struct { // Parameters: struct ibv_mw * mw; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_dealloc_mw_t; int ibv_dealloc_mw(struct ibv_mw * mw) { uhyve_ibv_dealloc_mw_t uhyve_args; uhyve_args.mw = mw; uhyve_send(UHYVE_PORT_IBV_DEALLOC_MW, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_inc_rkey */ typedef struct { // Parameters: uint32_t rkey; // Return value: uint32_t ret; } __attribute__((packed)) uhyve_ibv_inc_rkey_t; uint32_t ibv_inc_rkey(uint32_t rkey) { uhyve_ibv_inc_rkey_t uhyve_args; uhyve_args.rkey = rkey; uhyve_send(UHYVE_PORT_IBV_INC_RKEY, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_bind_mw */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_mw * mw; struct ibv_mw_bind * mw_bind; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_bind_mw_t; int ibv_bind_mw(struct ibv_qp * qp, struct ibv_mw * mw, struct ibv_mw_bind * mw_bind) { uhyve_ibv_bind_mw_t uhyve_args; uhyve_args.qp = qp; uhyve_args.mw = mw; uhyve_args.mw_bind = (struct ibv_mw_bind *) guest_to_host((size_t) mw_bind); uhyve_send(UHYVE_PORT_IBV_BIND_MW, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_comp_channel */ typedef struct { // Parameters: struct ibv_context * context; // Return value: struct ibv_comp_channel * ret; } __attribute__((packed)) uhyve_ibv_create_comp_channel_t; struct ibv_comp_channel * ibv_create_comp_channel(struct ibv_context * context) { uhyve_ibv_create_comp_channel_t uhyve_args; uhyve_args.context = context; uhyve_send(UHYVE_PORT_IBV_CREATE_COMP_CHANNEL, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_comp_channel */ typedef struct { // Parameters: struct ibv_comp_channel * channel; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_comp_channel_t; int ibv_destroy_comp_channel(struct ibv_comp_channel * channel) { uhyve_ibv_destroy_comp_channel_t uhyve_args; uhyve_args.channel = channel; uhyve_send(UHYVE_PORT_IBV_DESTROY_COMP_CHANNEL, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_cq */ typedef struct { // Parameters: struct ibv_context * context; int cqe; void * cq_context; struct ibv_comp_channel * channel; int comp_vector; // Return value: struct ibv_cq * ret; } __attribute__((packed)) uhyve_ibv_create_cq_t; struct ibv_cq * ibv_create_cq(struct ibv_context * context, int cqe, void * cq_context, struct ibv_comp_channel * channel, int comp_vector) { uhyve_ibv_create_cq_t uhyve_args; uhyve_args.context = context; uhyve_args.cqe = cqe; uhyve_args.cq_context = (void *) guest_to_host((size_t) cq_context); uhyve_args.channel = channel; uhyve_args.comp_vector = comp_vector; uhyve_send(UHYVE_PORT_IBV_CREATE_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_cq_ex */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_cq_init_attr_ex * cq_attr; // Return value: struct ibv_cq_ex * ret; } __attribute__((packed)) uhyve_ibv_create_cq_ex_t; struct ibv_cq_ex * ibv_create_cq_ex(struct ibv_context * context, struct ibv_cq_init_attr_ex * cq_attr) { uhyve_ibv_create_cq_ex_t uhyve_args; uhyve_args.context = context; uhyve_args.cq_attr = (struct ibv_cq_init_attr_ex *) guest_to_host((size_t) cq_attr); uhyve_send(UHYVE_PORT_IBV_CREATE_CQ_EX, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_resize_cq */ typedef struct { // Parameters: struct ibv_cq * cq; int cqe; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_resize_cq_t; int ibv_resize_cq(struct ibv_cq * cq, int cqe) { uhyve_ibv_resize_cq_t uhyve_args; uhyve_args.cq = cq; uhyve_args.cqe = cqe; uhyve_send(UHYVE_PORT_IBV_RESIZE_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_cq */ typedef struct { // Parameters: struct ibv_cq * cq; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_cq_t; int ibv_destroy_cq(struct ibv_cq * cq) { uhyve_ibv_destroy_cq_t uhyve_args; uhyve_args.cq = cq; uhyve_send(UHYVE_PORT_IBV_DESTROY_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_get_cq_event */ typedef struct { // Parameters: struct ibv_comp_channel * channel; struct ibv_cq ** cq; void ** cq_context; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_get_cq_event_t; int ibv_get_cq_event(struct ibv_comp_channel * channel, struct ibv_cq ** cq, void ** cq_context) { uhyve_ibv_get_cq_event_t uhyve_args; uhyve_args.channel = channel; uhyve_args.cq = cq; uhyve_args.cq_context = (void **) guest_to_host((size_t) cq_context); // TODO: Check ** param here. uhyve_send(UHYVE_PORT_IBV_GET_CQ_EVENT, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_ack_cq_events */ typedef struct { // Parameters: struct ibv_cq * cq; unsigned int nevents; } __attribute__((packed)) uhyve_ibv_ack_cq_events_t; void ibv_ack_cq_events(struct ibv_cq * cq, unsigned int nevents) { uhyve_ibv_ack_cq_events_t uhyve_args; uhyve_args.cq = cq; uhyve_args.nevents = nevents; uhyve_send(UHYVE_PORT_IBV_ACK_CQ_EVENTS, (unsigned) virt_to_phys((size_t) &uhyve_args)); } /* * ibv_poll_cq */ typedef struct { // Parameters: struct ibv_cq * cq; int num_entries; struct ibv_wc * wc; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_poll_cq_t; int ibv_poll_cq(struct ibv_cq * cq, int num_entries, struct ibv_wc * wc) { uhyve_ibv_poll_cq_t uhyve_args; uhyve_args.cq = cq; uhyve_args.num_entries = num_entries; uhyve_args.wc = (struct ibv_wc *) guest_to_host((size_t) wc); uhyve_send(UHYVE_PORT_IBV_POLL_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_req_notify_cq */ typedef struct { // Parameters: struct ibv_cq * cq; int solicited_only; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_req_notify_cq_t; int ibv_req_notify_cq(struct ibv_cq * cq, int solicited_only) { uhyve_ibv_req_notify_cq_t uhyve_args; uhyve_args.cq = cq; uhyve_args.solicited_only = solicited_only; uhyve_send(UHYVE_PORT_IBV_REQ_NOTIFY_CQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_srq */ typedef struct { // Parameters: struct ibv_pd * pd; struct ibv_srq_init_attr * srq_init_attr; // Return value: struct ibv_srq * ret; } __attribute__((packed)) uhyve_ibv_create_srq_t; struct ibv_srq * ibv_create_srq(struct ibv_pd * pd, struct ibv_srq_init_attr * srq_init_attr) { uhyve_ibv_create_srq_t uhyve_args; uhyve_args.pd = pd; uhyve_args.srq_init_attr = (struct ibv_srq_init_attr *) guest_to_host((size_t) srq_init_attr); uhyve_send(UHYVE_PORT_IBV_CREATE_SRQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_srq_ex */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_srq_init_attr_ex * srq_init_attr_ex; // Return value: struct ibv_srq * ret; } __attribute__((packed)) uhyve_ibv_create_srq_ex_t; struct ibv_srq * ibv_create_srq_ex(struct ibv_context * context, struct ibv_srq_init_attr_ex * srq_init_attr_ex) { uhyve_ibv_create_srq_ex_t uhyve_args; uhyve_args.context = context; uhyve_args.srq_init_attr_ex = (struct ibv_srq_init_attr_ex *) guest_to_host((size_t) srq_init_attr_ex); uhyve_send(UHYVE_PORT_IBV_CREATE_SRQ_EX, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_modify_srq */ typedef struct { // Parameters: struct ibv_srq * srq; struct ibv_srq_attr * srq_attr; int srq_attr_mask; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_modify_srq_t; int ibv_modify_srq(struct ibv_srq * srq, struct ibv_srq_attr * srq_attr, int srq_attr_mask) { uhyve_ibv_modify_srq_t uhyve_args; uhyve_args.srq = srq; uhyve_args.srq_attr = (struct ibv_srq_attr *) guest_to_host((size_t) srq_attr); uhyve_args.srq_attr_mask = srq_attr_mask; uhyve_send(UHYVE_PORT_IBV_MODIFY_SRQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_srq */ typedef struct { // Parameters: struct ibv_srq * srq; struct ibv_srq_attr * srq_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_srq_t; int ibv_query_srq(struct ibv_srq * srq, struct ibv_srq_attr * srq_attr) { uhyve_ibv_query_srq_t uhyve_args; uhyve_args.srq = srq; uhyve_args.srq_attr = (struct ibv_srq_attr *) guest_to_host((size_t) srq_attr); uhyve_send(UHYVE_PORT_IBV_QUERY_SRQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_get_srq_num */ typedef struct { // Parameters: struct ibv_srq * srq; uint32_t * srq_num; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_get_srq_num_t; int ibv_get_srq_num(struct ibv_srq * srq, uint32_t * srq_num) { uhyve_ibv_get_srq_num_t uhyve_args; uhyve_args.srq = srq; uhyve_args.srq_num = (uint32_t *) guest_to_host((size_t) srq_num); uhyve_send(UHYVE_PORT_IBV_GET_SRQ_NUM, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_srq */ typedef struct { // Parameters: struct ibv_srq * srq; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_srq_t; int ibv_destroy_srq(struct ibv_srq * srq) { uhyve_ibv_destroy_srq_t uhyve_args; uhyve_args.srq = srq; uhyve_send(UHYVE_PORT_IBV_DESTROY_SRQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_post_srq_recv */ typedef struct { // Parameters: struct ibv_srq * srq; struct ibv_recv_wr * recv_wr; struct ibv_recv_wr ** bad_recv_wr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_post_srq_recv_t; int ibv_post_srq_recv(struct ibv_srq * srq, struct ibv_recv_wr * recv_wr, struct ibv_recv_wr ** bad_recv_wr) { uhyve_ibv_post_srq_recv_t uhyve_args; uhyve_args.srq = srq; uhyve_args.recv_wr = (struct ibv_recv_wr *) guest_to_host((size_t) recv_wr); uhyve_args.bad_recv_wr = (struct ibv_recv_wr **) guest_to_host((size_t) bad_recv_wr); // TODO: Check ** param here. struct ibv_recv_wr * curr_wr; int num_sges_max; int num_wrs; // Number of work requests in linked list and SGEs in each WR num_wrs = 0; num_sges_max = 0; for (curr_wr = recv_wr; curr_wr; curr_wr = curr_wr->next) { num_wrs++; if (num_sges_max < curr_wr->num_sge) { num_sges_max = curr_wr->num_sge; } } // Backup arrays for original guest memory pointers struct ibv_recv_wr * wr__next [num_wrs]; struct ibv_sge * wr__sg_list [num_wrs]; uint64_t wr__sg_list__addr[num_wrs][num_sges_max]; curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { // Next pointer wr__next[w] = curr_wr->next; curr_wr->next = (struct ibv_recv_wr *) guest_to_host((size_t) curr_wr->next); // SGE array for (int s = 0; s < curr_wr->num_sge; s++) { wr__sg_list__addr[w][s] = curr_wr->sg_list[s].addr; curr_wr->sg_list[s].addr = (uint64_t) guest_to_host((size_t) curr_wr->sg_list[s].addr); } wr__sg_list[w] = curr_wr->sg_list; curr_wr->sg_list = (struct ibv_sge *) guest_to_host((size_t) curr_wr->sg_list); curr_wr = wr__next[w]; } uhyve_send(UHYVE_PORT_IBV_POST_SRQ_RECV, (unsigned) virt_to_phys((size_t) &uhyve_args)); if (*bad_recv_wr && *bad_recv_wr == uhyve_args.recv_wr) { *bad_recv_wr = recv_wr; } curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { if (*bad_recv_wr && *bad_recv_wr == curr_wr->next) { *bad_recv_wr = wr__next[w]; } curr_wr->next = wr__next[w]; curr_wr->sg_list = wr__sg_list[w]; for (int s = 0; s < curr_wr->num_sge; s++) { curr_wr->sg_list[s].addr = wr__sg_list__addr[w][s]; } curr_wr = curr_wr->next; } return uhyve_args.ret; } /* * ibv_create_qp */ typedef struct { // Parameters: struct ibv_pd * pd; struct ibv_qp_init_attr * qp_init_attr; // Return value: struct ibv_qp * ret; } __attribute__((packed)) uhyve_ibv_create_qp_t; struct ibv_qp * ibv_create_qp(struct ibv_pd * pd, struct ibv_qp_init_attr * qp_init_attr) { uhyve_ibv_create_qp_t uhyve_args; uhyve_args.pd = pd; uhyve_args.qp_init_attr = (struct ibv_qp_init_attr *) guest_to_host((size_t) qp_init_attr); uhyve_send(UHYVE_PORT_IBV_CREATE_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_qp_ex */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_qp_init_attr_ex * qp_init_attr_ex; // Return value: struct ibv_qp * ret; } __attribute__((packed)) uhyve_ibv_create_qp_ex_t; struct ibv_qp * ibv_create_qp_ex(struct ibv_context * context, struct ibv_qp_init_attr_ex * qp_init_attr_ex) { uhyve_ibv_create_qp_ex_t uhyve_args; uhyve_args.context = context; uhyve_args.qp_init_attr_ex = (struct ibv_qp_init_attr_ex *) guest_to_host((size_t) qp_init_attr_ex); uhyve_send(UHYVE_PORT_IBV_CREATE_QP_EX, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_rt_values_ex */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_values_ex * values; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_rt_values_ex_t; int ibv_query_rt_values_ex(struct ibv_context * context, struct ibv_values_ex * values) { uhyve_ibv_query_rt_values_ex_t uhyve_args; uhyve_args.context = context; uhyve_args.values = (struct ibv_values_ex *) guest_to_host((size_t) values); uhyve_send(UHYVE_PORT_IBV_QUERY_RT_VALUES_EX, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_device_ex */ typedef struct { // Parameters: struct ibv_context * context; const struct ibv_query_device_ex_input * input; struct ibv_device_attr_ex * attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_device_ex_t; int ibv_query_device_ex(struct ibv_context * context, const struct ibv_query_device_ex_input * input, struct ibv_device_attr_ex * attr) { uhyve_ibv_query_device_ex_t uhyve_args; uhyve_args.context = context; uhyve_args.input = (const struct ibv_query_device_ex_input *) guest_to_host((size_t) input); uhyve_args.attr = (struct ibv_device_attr_ex *) guest_to_host((size_t) attr); uhyve_send(UHYVE_PORT_IBV_QUERY_DEVICE_EX, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_open_qp */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_qp_open_attr * qp_open_attr; // Return value: struct ibv_qp * ret; } __attribute__((packed)) uhyve_ibv_open_qp_t; struct ibv_qp * ibv_open_qp(struct ibv_context * context, struct ibv_qp_open_attr * qp_open_attr) { uhyve_ibv_open_qp_t uhyve_args; uhyve_args.context = context; uhyve_args.qp_open_attr = (struct ibv_qp_open_attr *) guest_to_host((size_t) qp_open_attr); uhyve_send(UHYVE_PORT_IBV_OPEN_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_modify_qp */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_qp_attr * attr; int attr_mask; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_modify_qp_t; int ibv_modify_qp(struct ibv_qp * qp, struct ibv_qp_attr * attr, int attr_mask) { uhyve_ibv_modify_qp_t uhyve_args; uhyve_args.qp = qp; uhyve_args.attr = (struct ibv_qp_attr *) guest_to_host((size_t) attr); uhyve_args.attr_mask = attr_mask; uhyve_send(UHYVE_PORT_IBV_MODIFY_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_query_qp */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_qp_attr * attr; int attr_mask; struct ibv_qp_init_attr * init_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_query_qp_t; int ibv_query_qp(struct ibv_qp * qp, struct ibv_qp_attr * attr, int attr_mask, struct ibv_qp_init_attr * init_attr) { uhyve_ibv_query_qp_t uhyve_args; uhyve_args.qp = qp; uhyve_args.attr = (struct ibv_qp_attr *) guest_to_host((size_t) attr); uhyve_args.attr_mask = attr_mask; uhyve_args.init_attr = (struct ibv_qp_init_attr *) guest_to_host((size_t) init_attr); uhyve_send(UHYVE_PORT_IBV_QUERY_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_qp */ typedef struct { // Parameters: struct ibv_qp * qp; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_qp_t; int ibv_destroy_qp(struct ibv_qp * qp) { uhyve_ibv_destroy_qp_t uhyve_args; uhyve_args.qp = qp; uhyve_send(UHYVE_PORT_IBV_DESTROY_QP, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_wq */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_wq_init_attr * wq_init_attr; // Return value: struct ibv_wq * ret; } __attribute__((packed)) uhyve_ibv_create_wq_t; struct ibv_wq * ibv_create_wq(struct ibv_context * context, struct ibv_wq_init_attr * wq_init_attr) { uhyve_ibv_create_wq_t uhyve_args; uhyve_args.context = context; uhyve_args.wq_init_attr = (struct ibv_wq_init_attr *) guest_to_host((size_t) wq_init_attr); uhyve_send(UHYVE_PORT_IBV_CREATE_WQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_modify_wq */ typedef struct { // Parameters: struct ibv_wq * wq; struct ibv_wq_attr * wq_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_modify_wq_t; int ibv_modify_wq(struct ibv_wq * wq, struct ibv_wq_attr * wq_attr) { uhyve_ibv_modify_wq_t uhyve_args; uhyve_args.wq = wq; uhyve_args.wq_attr = (struct ibv_wq_attr *) guest_to_host((size_t) wq_attr); uhyve_send(UHYVE_PORT_IBV_MODIFY_WQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_wq */ typedef struct { // Parameters: struct ibv_wq * wq; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_wq_t; int ibv_destroy_wq(struct ibv_wq * wq) { uhyve_ibv_destroy_wq_t uhyve_args; uhyve_args.wq = wq; uhyve_send(UHYVE_PORT_IBV_DESTROY_WQ, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_rwq_ind_table */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_rwq_ind_table_init_attr * init_attr; // Return value: struct ibv_rwq_ind_table * ret; } __attribute__((packed)) uhyve_ibv_create_rwq_ind_table_t; struct ibv_rwq_ind_table * ibv_create_rwq_ind_table(struct ibv_context * context, struct ibv_rwq_ind_table_init_attr * init_attr) { uhyve_ibv_create_rwq_ind_table_t uhyve_args; uhyve_args.context = context; uhyve_args.init_attr = (struct ibv_rwq_ind_table_init_attr *) guest_to_host((size_t) init_attr); // TODO: Entries of the list should be universal references residing in the IB memory pool. // Confirm this. struct ibv_wq ** init_attr__ind_tbl = init_attr->ind_tbl; init_attr->ind_tbl = (struct ibv_wq **) guest_to_host((size_t) init_attr->ind_tbl); uhyve_send(UHYVE_PORT_IBV_CREATE_RWQ_IND_TABLE, (unsigned) virt_to_phys((size_t) &uhyve_args)); init_attr->ind_tbl = init_attr__ind_tbl; return uhyve_args.ret; } /* * ibv_destroy_rwq_ind_table */ typedef struct { // Parameters: struct ibv_rwq_ind_table * rwq_ind_table; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_rwq_ind_table_t; int ibv_destroy_rwq_ind_table(struct ibv_rwq_ind_table * rwq_ind_table) { uhyve_ibv_destroy_rwq_ind_table_t uhyve_args; uhyve_args.rwq_ind_table = rwq_ind_table; uhyve_send(UHYVE_PORT_IBV_DESTROY_RWQ_IND_TABLE, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_post_send */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_send_wr * wr; struct ibv_send_wr ** bad_wr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_post_send_t; int ibv_post_send(struct ibv_qp * qp, struct ibv_send_wr * wr, struct ibv_send_wr ** bad_wr) { uhyve_ibv_post_send_t uhyve_args; uhyve_args.qp = qp; uhyve_args.wr = (struct ibv_send_wr *) guest_to_host((size_t) wr); uhyve_args.bad_wr = (struct ibv_send_wr **) guest_to_host((size_t) bad_wr); // TODO: Check ** param here. struct ibv_send_wr * curr_wr; int num_wrs; int num_sges_max; int is_bind_mw, is_tso; // Number of work requests in linked list and SGEs in each WR num_wrs = 0; num_sges_max = 0; for (curr_wr = wr; curr_wr; curr_wr = curr_wr->next) { num_wrs++; if (num_sges_max < curr_wr->num_sge) { num_sges_max = curr_wr->num_sge; } } // Backup arrays for original guest memory pointers struct ibv_send_wr * wr__next [num_wrs]; struct ibv_sge * wr__sg_list [num_wrs]; uint64_t wr__sg_list__addr [num_wrs][num_sges_max]; uint64_t wr__bind_mw__bind_info__addr[num_wrs]; void * wr__tso__hdr [num_wrs]; curr_wr = wr; for (int w = 0; w < num_wrs; w++) { is_bind_mw = curr_wr->opcode == IBV_WR_BIND_MW; is_tso = curr_wr->opcode == IBV_WR_TSO; // union: bind_mw and tso if (is_bind_mw) { wr__bind_mw__bind_info__addr[w] = curr_wr->bind_mw.bind_info.addr; curr_wr->bind_mw.bind_info.addr = (uint64_t) guest_to_host((size_t) curr_wr->bind_mw.bind_info.addr); } else if (is_tso) { wr__tso__hdr[w] = curr_wr->tso.hdr; curr_wr->tso.hdr = (void *) guest_to_host((size_t) curr_wr->tso.hdr); } // Next pointer and SGE array wr__next[w] = curr_wr->next; curr_wr->next = (struct ibv_send_wr *) guest_to_host((size_t) curr_wr->next); for (int s = 0; s < curr_wr->num_sge; s++) { wr__sg_list__addr[w][s] = curr_wr->sg_list[s].addr; curr_wr->sg_list[s].addr = (uint64_t) guest_to_host((size_t) curr_wr->sg_list[s].addr); } wr__sg_list[w] = curr_wr->sg_list; curr_wr->sg_list = (struct ibv_sge *) guest_to_host((size_t) curr_wr->sg_list); curr_wr = wr__next[w]; } uhyve_send(UHYVE_PORT_IBV_POST_SEND, (unsigned) virt_to_phys((size_t) &uhyve_args)); if (*bad_wr && *bad_wr == uhyve_args.wr) { *bad_wr = wr; } curr_wr = wr; for (int w = 0; w < num_wrs; w++) { is_bind_mw = curr_wr->opcode == IBV_WR_BIND_MW; is_tso = curr_wr->opcode == IBV_WR_TSO; // union: bind_mw and tso if (is_bind_mw) { curr_wr->bind_mw.bind_info.addr = wr__bind_mw__bind_info__addr[w]; } else if (is_tso) { curr_wr->tso.hdr = wr__tso__hdr[w]; } // Bad request if (*bad_wr && *bad_wr == curr_wr->next) { *bad_wr = wr__next[w]; } // Next pointer and SGE array curr_wr->next = wr__next[w]; curr_wr->sg_list = wr__sg_list[w]; for (int s = 0; s < curr_wr->num_sge; s++) { curr_wr->sg_list[s].addr = wr__sg_list__addr[w][s]; } curr_wr = curr_wr->next; } return uhyve_args.ret; } /* * ibv_post_recv */ typedef struct { // Parameters: struct ibv_qp * qp; struct ibv_recv_wr * recv_wr; struct ibv_recv_wr ** bad_recv_wr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_post_recv_t; int ibv_post_recv(struct ibv_qp * qp, struct ibv_recv_wr * recv_wr, struct ibv_recv_wr ** bad_recv_wr) { uhyve_ibv_post_recv_t uhyve_args; uhyve_args.qp = qp; uhyve_args.recv_wr = (struct ibv_recv_wr *) guest_to_host((size_t) recv_wr); uhyve_args.bad_recv_wr = (struct ibv_recv_wr **) guest_to_host((size_t) bad_recv_wr); // TODO: Check ** param here. struct ibv_recv_wr * curr_wr; int num_sges_max; int num_wrs; // Number of work requests in linked list and SGEs in each WR num_wrs = 0; num_sges_max = 0; for (curr_wr = recv_wr; curr_wr; curr_wr = curr_wr->next) { num_wrs++; if (num_sges_max < curr_wr->num_sge) { num_sges_max = curr_wr->num_sge; } } // Backup arrays for original guest memory pointers struct ibv_recv_wr * wr__next [num_wrs]; struct ibv_sge * wr__sg_list [num_wrs]; uint64_t wr__sg_list__addr[num_wrs][num_sges_max]; curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { // Next pointer wr__next[w] = curr_wr->next; curr_wr->next = (struct ibv_recv_wr *) guest_to_host((size_t) curr_wr->next); // SGE array for (int s = 0; s < curr_wr->num_sge; s++) { wr__sg_list__addr[w][s] = curr_wr->sg_list[s].addr; curr_wr->sg_list[s].addr = (uint64_t) guest_to_host((size_t) curr_wr->sg_list[s].addr); } wr__sg_list[w] = curr_wr->sg_list; curr_wr->sg_list = (struct ibv_sge *) guest_to_host((size_t) curr_wr->sg_list); curr_wr = wr__next[w]; } uhyve_send(UHYVE_PORT_IBV_POST_RECV, (unsigned) virt_to_phys((size_t) &uhyve_args)); if (*bad_recv_wr && *bad_recv_wr == uhyve_args.recv_wr) { *bad_recv_wr = recv_wr; } curr_wr = recv_wr; for (int w = 0; w < num_wrs; w++) { if (*bad_recv_wr && *bad_recv_wr == curr_wr->next) { *bad_recv_wr = wr__next[w]; } curr_wr->next = wr__next[w]; curr_wr->sg_list = wr__sg_list[w]; for (int s = 0; s < curr_wr->num_sge; s++) { curr_wr->sg_list[s].addr = wr__sg_list__addr[w][s]; } curr_wr = curr_wr->next; } return uhyve_args.ret; } /* * ibv_create_ah */ typedef struct { // Parameters: struct ibv_pd * pd; struct ibv_ah_attr * attr; // Return value: struct ibv_ah * ret; } __attribute__((packed)) uhyve_ibv_create_ah_t; struct ibv_ah * ibv_create_ah(struct ibv_pd * pd, struct ibv_ah_attr * attr) { uhyve_ibv_create_ah_t uhyve_args; uhyve_args.pd = pd; uhyve_args.attr = (struct ibv_ah_attr *) guest_to_host((size_t) attr); uhyve_send(UHYVE_PORT_IBV_CREATE_AH, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_init_ah_from_wc */ typedef struct { // Parameters: struct ibv_context * context; uint8_t port_num; struct ibv_wc * wc; struct ibv_grh * grh; struct ibv_ah_attr * ah_attr; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_init_ah_from_wc_t; int ibv_init_ah_from_wc(struct ibv_context * context, uint8_t port_num, struct ibv_wc * wc, struct ibv_grh * grh, struct ibv_ah_attr * ah_attr) { uhyve_ibv_init_ah_from_wc_t uhyve_args; uhyve_args.context = context; uhyve_args.port_num = port_num; uhyve_args.wc = (struct ibv_wc *) guest_to_host((size_t) wc); uhyve_args.grh = (struct ibv_grh *) guest_to_host((size_t) grh); uhyve_args.ah_attr = (struct ibv_ah_attr *) guest_to_host((size_t) ah_attr); uhyve_send(UHYVE_PORT_IBV_INIT_AH_FROM_WC, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_create_ah_from_wc */ typedef struct { // Parameters: struct ibv_pd * pd; struct ibv_wc * wc; struct ibv_grh * grh; uint8_t port_num; // Return value: struct ibv_ah * ret; } __attribute__((packed)) uhyve_ibv_create_ah_from_wc_t; struct ibv_ah * ibv_create_ah_from_wc(struct ibv_pd * pd, struct ibv_wc * wc, struct ibv_grh * grh, uint8_t port_num) { uhyve_ibv_create_ah_from_wc_t uhyve_args; uhyve_args.pd = pd; uhyve_args.wc = (struct ibv_wc *) guest_to_host((size_t) wc); uhyve_args.grh = (struct ibv_grh *) guest_to_host((size_t) grh); uhyve_args.port_num = port_num; uhyve_send(UHYVE_PORT_IBV_CREATE_AH_FROM_WC, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_destroy_ah */ typedef struct { // Parameters: struct ibv_ah * ah; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_destroy_ah_t; int ibv_destroy_ah(struct ibv_ah * ah) { uhyve_ibv_destroy_ah_t uhyve_args; uhyve_args.ah = ah; uhyve_send(UHYVE_PORT_IBV_DESTROY_AH, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_attach_mcast */ typedef struct { // Parameters: struct ibv_qp * qp; const union ibv_gid * gid; uint16_t lid; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_attach_mcast_t; int ibv_attach_mcast(struct ibv_qp * qp, const union ibv_gid * gid, uint16_t lid) { uhyve_ibv_attach_mcast_t uhyve_args; uhyve_args.qp = qp; uhyve_args.gid = (const union ibv_gid *) guest_to_host((size_t) gid); uhyve_args.lid = lid; uhyve_send(UHYVE_PORT_IBV_ATTACH_MCAST, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_detach_mcast */ typedef struct { // Parameters: struct ibv_qp * qp; const union ibv_gid * gid; uint16_t lid; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_detach_mcast_t; int ibv_detach_mcast(struct ibv_qp * qp, const union ibv_gid * gid, uint16_t lid) { uhyve_ibv_detach_mcast_t uhyve_args; uhyve_args.qp = qp; uhyve_args.gid = (const union ibv_gid *) guest_to_host((size_t) gid); uhyve_args.lid = lid; uhyve_send(UHYVE_PORT_IBV_DETACH_MCAST, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_fork_init */ typedef struct { // Return value: int ret; } __attribute__((packed)) uhyve_ibv_fork_init_t; int ibv_fork_init() { uhyve_ibv_fork_init_t uhyve_args; uhyve_send(UHYVE_PORT_IBV_FORK_INIT, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_node_type_str */ typedef struct { // Parameters: enum ibv_node_type node_type; // Return value: const char * ret; } __attribute__((packed)) uhyve_ibv_node_type_str_t; const char * ibv_node_type_str(enum ibv_node_type node_type) { uhyve_ibv_node_type_str_t uhyve_args; uhyve_args.node_type = node_type; uhyve_send(UHYVE_PORT_IBV_NODE_TYPE_STR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_port_state_str */ typedef struct { // Parameters: enum ibv_port_state port_state; // Return value: const char * ret; } __attribute__((packed)) uhyve_ibv_port_state_str_t; const char * ibv_port_state_str(enum ibv_port_state port_state) { uhyve_ibv_port_state_str_t uhyve_args; uhyve_args.port_state = port_state; uhyve_send(UHYVE_PORT_IBV_PORT_STATE_STR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_event_type_str */ typedef struct { // Parameters: enum ibv_event_type event; // Return value: const char * ret; } __attribute__((packed)) uhyve_ibv_event_type_str_t; const char * ibv_event_type_str(enum ibv_event_type event) { uhyve_ibv_event_type_str_t uhyve_args; uhyve_args.event = event; uhyve_send(UHYVE_PORT_IBV_EVENT_TYPE_STR, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_resolve_eth_l2_from_gid */ typedef struct { // Parameters: struct ibv_context * context; struct ibv_ah_attr * attr; uint8_t eth_mac[6]; uint16_t * vid; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_resolve_eth_l2_from_gid_t; int ibv_resolve_eth_l2_from_gid(struct ibv_context * context, struct ibv_ah_attr * attr, uint8_t eth_mac[6], uint16_t * vid) { uhyve_ibv_resolve_eth_l2_from_gid_t uhyve_args; uhyve_args.context = context; uhyve_args.attr = (struct ibv_ah_attr *) guest_to_host((size_t) attr); uhyve_args.eth_mac[6] = eth_mac[6]; uhyve_args.vid = (uint16_t *) guest_to_host((size_t) vid); uhyve_send(UHYVE_PORT_IBV_RESOLVE_ETH_L2_FROM_GID, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; } /* * ibv_is_qpt_supported */ typedef struct { // Parameters: uint32_t caps; enum ibv_qp_type qpt; // Return value: int ret; } __attribute__((packed)) uhyve_ibv_is_qpt_supported_t; int ibv_is_qpt_supported(uint32_t caps, enum ibv_qp_type qpt) { uhyve_ibv_is_qpt_supported_t uhyve_args; uhyve_args.caps = caps; uhyve_args.qpt = qpt; uhyve_send(UHYVE_PORT_IBV_IS_QPT_SUPPORTED, (unsigned) virt_to_phys((size_t) &uhyve_args)); return uhyve_args.ret; }