/*
 * 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;
}