mirror of
https://github.com/hermitcore/libhermit.git
synced 2025-03-09 00:00:03 +01:00
Added phys_to_virt function. Adapting ibv prototype almost done.
This commit is contained in:
Annika Wierichs
parent
2faf331052
commit
ad49a935b2
5 changed files with 213 additions and 221 deletions
|
|
@ -53,6 +53,7 @@
|
|||
#else
|
||||
#define PAGE_MASK (((~0UL) << PAGE_BITS) & ~PG_XD)
|
||||
#define PAGE_2M_MASK (((~0UL) << PAGE_2M_BITS) & ~PG_XD)
|
||||
#define PFN_MASK (PAGE_MASK & ~(~0UL << PHYS_BITS))
|
||||
#endif
|
||||
|
||||
#if 0
|
||||
|
|
@ -156,6 +157,16 @@ static inline size_t sign_extend(ssize_t addr, int bits)
|
|||
*/
|
||||
size_t virt_to_phys(size_t vir);
|
||||
|
||||
/** @brief Converts a physical address to a virtual
|
||||
*
|
||||
* Careful: Linear runtime of O(n) (worst case) where n is the number of mapped
|
||||
* PGT entries. Returns 0 for a physical address that is not mapped.
|
||||
*
|
||||
* @param phy Physical address to convert
|
||||
* @return Virtual address
|
||||
*/
|
||||
size_t phys_to_virt(size_t phy);
|
||||
|
||||
/** @brief Initialize paging subsystem
|
||||
*
|
||||
* This function uses the existing bootstrap page tables (boot_{pgd, pgt})
|
||||
|
|
|
|||
|
|
@ -115,8 +115,11 @@ size_t virt_to_phys(size_t addr)
|
|||
}
|
||||
}
|
||||
|
||||
size_t phys_to_virt(size_t addr)
|
||||
size_t phys_to_virt(size_t phy)
|
||||
{
|
||||
size_t pfn = phy & PFN_MASK;
|
||||
size_t off = phy & ~PAGE_MASK;
|
||||
|
||||
size_t * pml4 = self[PAGE_LEVELS-1];
|
||||
for(size_t i=0; i<(1 << PAGE_MAP_BITS); i++) {
|
||||
if (!(pml4[i] & PG_PRESENT)) {
|
||||
|
|
@ -137,13 +140,23 @@ size_t phys_to_virt(size_t addr)
|
|||
|
||||
size_t * pgt = (size_t *) (pgd[k] & PAGE_MASK);
|
||||
for(size_t l=0; l<(1 << PAGE_MAP_BITS); l++) {
|
||||
if (pgt[l] & PG_PRESENT) {
|
||||
// TODO
|
||||
|
||||
if (pgt[l] & PG_PRESENT) { // Valid page table entry
|
||||
if ((pgt[l] & PFN_MASK) == pfn) { // Page frame found
|
||||
size_t vpn = ((((((i << PAGE_MAP_BITS) & j) << PAGE_MAP_BITS) & k) << PAGE_MAP_BITS) & l) << PAGE_BITS;
|
||||
size_t sext = i & (1UL << (PAGE_MAP_BITS - 1));
|
||||
if (sext) {
|
||||
vpn |= ~0UL << VIRT_BITS;
|
||||
}
|
||||
return vpn & off;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -34,7 +34,7 @@
|
|||
#include <hermit/verbs.h>
|
||||
|
||||
extern uint8_t * kernel_start_host;
|
||||
|
||||
typedef enum {GUEST, HOST} addr_type;
|
||||
|
||||
inline size_t guest_to_host(size_t address) {
|
||||
return address ? virt_to_phys(address) + (size_t) kernel_start_host : address;
|
||||
|
|
@ -53,11 +53,11 @@ struct ibv_comp_channel * guest_to_host_ibv_comp_channel(struct ibv_comp_channe
|
|||
struct ibv_abi_compat_v2 * guest_to_host_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat);
|
||||
pthread_mutex_t * guest_to_host_pthread_mutex_t(pthread_mutex_t * mutex);
|
||||
|
||||
void host_to_guest_ibv_device(struct ibv_device * device);
|
||||
void host_to_guest_ibv_context(struct ibv_context * context);
|
||||
void host_to_guest_ibv_context_ops(struct ibv_context_ops * context_ops);
|
||||
void host_to_guest_ibv_port_attr(struct ibv_port_attr * port_attr);
|
||||
void host_to_guest_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat);
|
||||
void host_to_guest_pthread_mutex_t(pthread_mutex_t * mutex);
|
||||
struct ibv_device * host_to_guest_ibv_device(struct ibv_device * device, addr_type type);
|
||||
struct ibv_context * host_to_guest_ibv_context(struct ibv_context * context, addr_type type);
|
||||
struct ibv_context_ops * host_to_guest_ibv_context_ops(struct ibv_context_ops * context_ops, addr_type type);
|
||||
struct ibv_port_attr * host_to_guest_ibv_port_attr(struct ibv_port_attr * port_attr, addr_type type);
|
||||
struct ibv_abi_compat_v2 * host_to_guest_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat, addr_type type);
|
||||
pthread_mutex_t * host_to_guest_pthread_mutex_t(pthread_mutex_t * mutex, addr_type type);
|
||||
|
||||
#endif // __IBV_GUEST_HOST_H__
|
||||
|
|
|
|||
37
kernel/ibv.c
37
kernel/ibv.c
|
|
@ -44,7 +44,6 @@
|
|||
// allocate the right amount of memory?
|
||||
#define MAX_NUM_OF_IBV_DEVICES 16
|
||||
|
||||
|
||||
static void * ret_guest;
|
||||
|
||||
|
||||
|
|
@ -79,10 +78,7 @@ struct ibv_device ** ibv_get_device_list(int * num_devices) {
|
|||
uhyve_send(UHYVE_PORT_IBV_GET_DEVICE_LIST, (unsigned) virt_to_phys((size_t) &uhyve_args));
|
||||
|
||||
for (int i = 0; i < MAX_NUM_OF_IBV_DEVICES; i++) {
|
||||
host_to_guest_ibv_device(ret_guest[i]);
|
||||
struct ibv_device * device_address = devs + i;
|
||||
ret_guest[i] = device_address;
|
||||
uhyve_args.ret[i] = (struct ibv_device *) guest_to_host((size_t) device_address);
|
||||
host_to_guest_ibv_device(ret_guest[i], GUEST);
|
||||
}
|
||||
|
||||
return ret_guest;
|
||||
|
|
@ -97,7 +93,7 @@ typedef struct {
|
|||
// Parameters:
|
||||
struct ibv_device * device;
|
||||
// Return value:
|
||||
const char * ret;
|
||||
char * ret; // TODO: const?
|
||||
} __attribute__((packed)) uhyve_ibv_get_device_name_t;
|
||||
|
||||
const char * ibv_get_device_name(struct ibv_device * device) {
|
||||
|
|
@ -106,17 +102,13 @@ const char * ibv_get_device_name(struct ibv_device * device) {
|
|||
|
||||
uhyve_send(UHYVE_PORT_IBV_GET_DEVICE_NAME, (unsigned) virt_to_phys((size_t) &uhyve_args));
|
||||
|
||||
host_to_guest_ibv_device(device);
|
||||
host_to_guest_ibv_device(device, GUEST);
|
||||
ret_guest = host_to_guest((size_t) uhyve_args.ret);
|
||||
// Lookup return address in hash map created earlier. Found? convert back.
|
||||
// Hack for testing, replace by line above.
|
||||
ret_guest = device->name;
|
||||
|
||||
return ret_guest;
|
||||
return (char *) ret_guest;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* ibv_open_device
|
||||
*/
|
||||
|
|
@ -129,19 +121,18 @@ typedef struct {
|
|||
} __attribute__((packed)) uhyve_ibv_open_device_t;
|
||||
|
||||
struct ibv_context * ibv_open_device(struct ibv_device * device) {
|
||||
/* printf("LOG: ibv_open_device"); */
|
||||
uhyve_ibv_open_device_t uhyve_args;
|
||||
uhyve_args.device = guest_to_host_ibv_device(device);
|
||||
|
||||
ret_guest = kmalloc(sizeof(struct ibv_context));
|
||||
uhyve_args.ret = (struct ibv_context *) guest_to_host((size_t) ret_guest);
|
||||
|
||||
uhyve_send(UHYVE_PORT_IBV_OPEN_DEVICE, (unsigned)virt_to_phys((size_t)&uhyve_args));
|
||||
uhyve_send(UHYVE_PORT_IBV_OPEN_DEVICE, (unsigned) virt_to_phys((size_t)&uhyve_args));
|
||||
|
||||
host_to_guest_ibv_device(device);
|
||||
host_to_guest_ibv_context((struct ibv_context * ) ret_guest);
|
||||
|
||||
return ret_guest;
|
||||
host_to_guest_ibv_device(device, GUEST);
|
||||
host_to_guest_ibv_context((struct ibv_context * ) ret_guest, GUEST);
|
||||
|
||||
return (struct ibv_context *) ret_guest;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -159,7 +150,6 @@ typedef struct {
|
|||
} __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) {
|
||||
/* printf("LOG: ibv_query_port"); */
|
||||
uhyve_ibv_query_port_t uhyve_args;
|
||||
uhyve_args.context = guest_to_host_ibv_context(context);
|
||||
uhyve_args.port_num = port_num;
|
||||
|
|
@ -167,8 +157,8 @@ int ibv_query_port(struct ibv_context * context, uint8_t port_num, struct ibv_po
|
|||
|
||||
uhyve_send(UHYVE_PORT_IBV_QUERY_PORT, (unsigned) virt_to_phys((size_t) &uhyve_args));
|
||||
|
||||
host_to_guest_ibv_context(context);
|
||||
host_to_guest_ibv_port_attr(port_attr);
|
||||
host_to_guest_ibv_context(context, GUEST);
|
||||
host_to_guest_ibv_port_attr(port_attr, GUEST);
|
||||
|
||||
return uhyve_args.ret;
|
||||
}
|
||||
|
|
@ -186,7 +176,6 @@ typedef struct {
|
|||
} __attribute__((packed)) uhyve_ibv_create_comp_channel_t;
|
||||
|
||||
struct ibv_comp_channel * ibv_create_comp_channel(struct ibv_context * context) {
|
||||
/* printf("LOG: ibv_create_comp_channel"); */
|
||||
uhyve_ibv_create_comp_channel_t uhyve_args;
|
||||
uhyve_args.context = guest_to_host_ibv_context(context);
|
||||
|
||||
|
|
@ -195,8 +184,8 @@ struct ibv_comp_channel * ibv_create_comp_channel(struct ibv_context * context)
|
|||
|
||||
uhyve_send(UHYVE_PORT_IBV_CREATE_COMP_CHANNEL, (unsigned) virt_to_phys((size_t) &uhyve_args));
|
||||
|
||||
host_to_guest_ibv_context(context);
|
||||
host_to_guest_ibv_comp_channel(ret_guest);
|
||||
host_to_guest_ibv_context(context, GUEST);
|
||||
host_to_guest_ibv_comp_channel((struct ibv_comp_channel *) ret_guest, GUEST);
|
||||
|
||||
return ret_guest;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -43,37 +43,114 @@ struct ibv_device * guest_to_host_ibv_device(struct ibv_device * device) {
|
|||
return (struct ibv_device *) guest_to_host((size_t) device);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_device(struct ibv_device * device) { }
|
||||
struct ibv_device * host_to_guest_ibv_device(struct ibv_device * device, addr_type type) {
|
||||
struct ibv_device * vaddr = (type == GUEST) ? device
|
||||
: (struct ibv_device *) host_to_guest((size_t) device);
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_context
|
||||
*/
|
||||
|
||||
/* static struct { */
|
||||
/* struct ibv_device * device; */
|
||||
/* void * abi_compat; */
|
||||
/* } ibv_context_virt_ptrs; */
|
||||
|
||||
struct ibv_context * guest_to_host_ibv_context(struct ibv_context * context) {
|
||||
ibv_context_virt_ptrs.device = context->device,
|
||||
ibv_context_virt_ptrs.abi_compat = context->abi_compat,
|
||||
|
||||
context->device = guest_to_host_ibv_device(context->device);
|
||||
context->abi_compat = guest_to_host_ibv_abi_compat_v2(context->abi_compat);
|
||||
|
||||
guest_to_host_ibv_context_ops(&context->ops);
|
||||
guest_to_host_pthread_mutex_t(&context->mutex); // TODO
|
||||
|
||||
return (struct ibv_context *) guest_to_host((size_t) context);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_context(struct ibv_context * context) {
|
||||
context->device = ibv_context_virt_ptrs.device;
|
||||
context->abi_compat = ibv_context_virt_ptrs.abi_compat;
|
||||
struct ibv_context * host_to_guest_ibv_context(struct ibv_context * context, addr_type type) {
|
||||
struct ibv_context * vaddr = (type == GUEST) ? context
|
||||
: (struct ibv_context *) host_to_guest((size_t) context);
|
||||
|
||||
host_to_guest_ibv_device(context->device);
|
||||
host_to_guest_ibv_abi_compat_v2(context->abi_compat);
|
||||
host_to_guest_ibv_context_ops(&context->ops);
|
||||
vaddr->device = host_to_guest_ibv_device(vaddr->device, HOST);
|
||||
vaddr->abi_compat = host_to_guest_ibv_abi_compat_v2(vaddr->abi_compat, HOST);
|
||||
|
||||
host_to_guest_ibv_context_ops(&vaddr->ops, GUEST);
|
||||
host_to_guest_pthread_mutex_t(&vaddr->mutex, GUEST);
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_port_attr
|
||||
*/
|
||||
|
||||
struct ibv_port_attr * guest_to_host_ibv_port_attr(struct ibv_port_attr * port_attr) {
|
||||
return (struct ibv_port_attr *) guest_to_host((size_t) port_attr);
|
||||
}
|
||||
|
||||
struct ibv_port_attr * host_to_guest_ibv_port_attr(struct ibv_port_attr * port_attr, addr_type type) {
|
||||
struct ibv_port_attr * vaddr = (type == GUEST) ? port_attr
|
||||
: (struct ibv_port_attr *) host_to_guest((size_t) port_attr);
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_comp_channel
|
||||
*/
|
||||
|
||||
struct ibv_comp_channel * guest_to_host_ibv_comp_channel(struct ibv_comp_channel * channel) {
|
||||
channel->context = guest_to_host_ibv_context(channel->context);
|
||||
|
||||
return (struct ibv_comp_channel *) guest_to_host((size_t) channel);
|
||||
}
|
||||
|
||||
struct ibv_comp_channel * host_to_guest_ibv_comp_channel(struct ibv_comp_channel * channel, addr_type type) {
|
||||
struct ibv_comp_channel * vaddr = (type == GUEST) ? channel
|
||||
: (struct ibv_comp_channel *) host_to_guest((size_t) channel);
|
||||
|
||||
vaddr->context = host_to_guest_ibv_context(vaddr->context, HOST);
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_abi_compat_v2
|
||||
*/
|
||||
|
||||
struct ibv_abi_compat_v2 * guest_to_host_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat) {
|
||||
guest_to_host_ibv_comp_channel(&abi_compat->channel);
|
||||
guest_to_host_pthread_mutex_t(&abi_compat->in_use);
|
||||
|
||||
return (struct ibv_abi_compat_v2 *) guest_to_host((size_t) abi_compat);
|
||||
}
|
||||
|
||||
struct ibv_abi_compat_v2 * host_to_guest_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat, addr_type type) {
|
||||
struct ibv_abi_compat_v2 * vaddr = (type == GUEST) ? abi_compat
|
||||
: (struct ibv_abi_compat_v2 *) host_to_guest((size_t) abi_compat);
|
||||
|
||||
host_to_guest_ibv_comp_channel(&abi_compat->channel, GUEST);
|
||||
host_to_guest_pthread_mutex_t(&abi_compat->in_use, GUEST);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* pthread_mutex_t
|
||||
*/
|
||||
|
||||
pthread_mutex_t * guest_to_host_pthread_mutex_t(pthread_mutex_t * mutex) {
|
||||
/* mutex->__m_owner = guest_to_host__pthread_descr(mutex->__m_owner); */
|
||||
|
||||
return (struct pthread_mutex_t *) guest_to_host((size_t) mutex);
|
||||
}
|
||||
|
||||
pthread_mutex_t * host_to_guest_pthread_mutex_t(pthread_mutex_t * mutex, addr_type type) {
|
||||
pthread_mutex_t * vaddr = (type == GUEST) ? mutex
|
||||
: (pthread_mutex_t *) host_to_guest((size_t) mutex);
|
||||
/* host_to_guest__pthread_descr(mutex->__m_owner); */
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -81,74 +158,7 @@ void host_to_guest_ibv_context(struct ibv_context * context) {
|
|||
* struct ibv_context_ops
|
||||
*/
|
||||
|
||||
/* static struct { */
|
||||
/* int (*query_device)(struct ibv_context *, struct ibv_device_attr *); */
|
||||
/* int (*query_port)(struct ibv_context *, uint8_t, struct ibv_port_attr *); */
|
||||
/* struct ibv_pd * (*alloc_pd)(struct ibv_context *); */
|
||||
/* int (*dealloc_pd)(struct ibv_pd *); */
|
||||
/* struct ibv_mr * (*reg_mr)(struct ibv_pd *, void *, size_t, int); */
|
||||
/* int (*rereg_mr)(struct ibv_mr *, int, struct ibv_pd *, void *, size_t, int); */
|
||||
/* int (*dereg_mr)(struct ibv_mr *); */
|
||||
/* struct ibv_mw * (*alloc_mw)(struct ibv_pd *, enum ibv_mw_type); */
|
||||
/* int (*bind_mw)(struct ibv_qp *, struct ibv_mw *, struct ibv_mw_bind *); */
|
||||
/* int (*dealloc_mw)(struct ibv_mw *); */
|
||||
/* struct ibv_cq * (*create_cq)(struct ibv_context *, int, struct ibv_comp_channel *, int); */
|
||||
/* int (*poll_cq)(struct ibv_cq *, int, struct ibv_wc *); */
|
||||
/* int (*req_notify_cq)(struct ibv_cq *, int); */
|
||||
/* void (*cq_event)(struct ibv_cq *); */
|
||||
/* int (*resize_cq)(struct ibv_cq *, int); */
|
||||
/* int (*destroy_cq)(struct ibv_cq *); */
|
||||
/* struct ibv_srq * (*create_srq)(struct ibv_pd *, struct ibv_srq_init_attr *); */
|
||||
/* int (*modify_srq)(struct ibv_srq *, struct ibv_srq_attr *, int); */
|
||||
/* int (*query_srq)(struct ibv_srq *, struct ibv_srq_attr *); */
|
||||
/* int (*destroy_srq)(struct ibv_srq *); */
|
||||
/* int (*post_srq_recv)(struct ibv_srq *, struct ibv_recv_wr *, struct ibv_recv_wr **); */
|
||||
/* struct ibv_qp * (*create_qp)(struct ibv_pd *, struct ibv_qp_init_attr *); */
|
||||
/* int (*query_qp)(struct ibv_qp *, struct ibv_qp_attr *, int, struct ibv_qp_init_attr *); */
|
||||
/* int (*modify_qp)(struct ibv_qp *, struct ibv_qp_attr *, int); */
|
||||
/* int (*destroy_qp)(struct ibv_qp *); */
|
||||
/* int (*post_send)(struct ibv_qp *, struct ibv_send_wr *, struct ibv_send_wr **); */
|
||||
/* int (*post_recv)(struct ibv_qp *, struct ibv_recv_wr *, struct ibv_recv_wr **); */
|
||||
/* struct ibv_ah * (*create_ah)(struct ibv_pd *, struct ibv_ah_attr *); */
|
||||
/* int (*destroy_ah)(struct ibv_ah *); */
|
||||
/* int (*attach_mcast)(struct ibv_qp *, const union ibv_gid *, uint16_t); */
|
||||
/* int (*detach_mcast)(struct ibv_qp *, const union ibv_gid *, uint16_t); */
|
||||
/* void (*async_event)(struct ibv_async_event *); */
|
||||
/* } ibv_context_ops_virt_ptrs; */
|
||||
|
||||
struct ibv_context_ops * guest_to_host_ibv_context_ops(struct ibv_context_ops * context_ops) {
|
||||
ibv_context_ops_virt_ptrs.query_device = context_ops->query_device;
|
||||
ibv_context_ops_virt_ptrs.query_port = context_ops->query_port;
|
||||
ibv_context_ops_virt_ptrs.alloc_pd = context_ops->alloc_pd;
|
||||
ibv_context_ops_virt_ptrs.dealloc_pd = context_ops->dealloc_pd;
|
||||
ibv_context_ops_virt_ptrs.reg_mr = context_ops->reg_mr;
|
||||
ibv_context_ops_virt_ptrs.rereg_mr = context_ops->rereg_mr;
|
||||
ibv_context_ops_virt_ptrs.dereg_mr = context_ops->dereg_mr;
|
||||
ibv_context_ops_virt_ptrs.alloc_mw = context_ops->alloc_mw;
|
||||
ibv_context_ops_virt_ptrs.bind_mw = context_ops->bind_mw;
|
||||
ibv_context_ops_virt_ptrs.dealloc_mw = context_ops->dealloc_mw;
|
||||
ibv_context_ops_virt_ptrs.create_cq = context_ops->create_cq;
|
||||
ibv_context_ops_virt_ptrs.poll_cq = context_ops->poll_cq;
|
||||
ibv_context_ops_virt_ptrs.req_notify_cq = context_ops->req_notify_cq;
|
||||
ibv_context_ops_virt_ptrs.cq_event = context_ops->cq_event;
|
||||
ibv_context_ops_virt_ptrs.resize_cq = context_ops->resize_cq;
|
||||
ibv_context_ops_virt_ptrs.destroy_cq = context_ops->destroy_cq;
|
||||
ibv_context_ops_virt_ptrs.create_srq = context_ops->create_srq;
|
||||
ibv_context_ops_virt_ptrs.modify_srq = context_ops->modify_srq;
|
||||
ibv_context_ops_virt_ptrs.query_srq = context_ops->query_srq;
|
||||
ibv_context_ops_virt_ptrs.destroy_srq = context_ops->destroy_srq;
|
||||
ibv_context_ops_virt_ptrs.post_srq_recv = context_ops->post_srq_recv;
|
||||
ibv_context_ops_virt_ptrs.create_qp = context_ops->create_qp;
|
||||
ibv_context_ops_virt_ptrs.query_qp = context_ops->query_qp;
|
||||
ibv_context_ops_virt_ptrs.modify_qp = context_ops->modify_qp;
|
||||
ibv_context_ops_virt_ptrs.destroy_qp = context_ops->destroy_qp;
|
||||
ibv_context_ops_virt_ptrs.post_send = context_ops->post_send;
|
||||
ibv_context_ops_virt_ptrs.post_recv = context_ops->post_recv;
|
||||
ibv_context_ops_virt_ptrs.create_ah = context_ops->create_ah;
|
||||
ibv_context_ops_virt_ptrs.destroy_ah = context_ops->destroy_ah;
|
||||
ibv_context_ops_virt_ptrs.attach_mcast = context_ops->attach_mcast;
|
||||
ibv_context_ops_virt_ptrs.detach_mcast = context_ops->detach_mcast;
|
||||
ibv_context_ops_virt_ptrs.async_event = context_ops->async_event;
|
||||
|
||||
// TODO: Does this work? Fcn returns size_t. Have to convert?
|
||||
context_ops->query_device = guest_to_host((size_t) context_ops->query_device);
|
||||
|
|
@ -187,109 +197,78 @@ struct ibv_context_ops * guest_to_host_ibv_context_ops(struct ibv_context_ops *
|
|||
return (struct ibv_context_ops *) guest_to_host((size_t) context_ops);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_context_ops(struct ibv_context_ops * context_ops) {
|
||||
context_ops->query_device = ibv_context_ops_virt_ptrs.query_device;
|
||||
context_ops->query_port = ibv_context_ops_virt_ptrs.query_port;
|
||||
context_ops->alloc_pd = ibv_context_ops_virt_ptrs.alloc_pd;
|
||||
context_ops->dealloc_pd = ibv_context_ops_virt_ptrs.dealloc_pd;
|
||||
context_ops->reg_mr = ibv_context_ops_virt_ptrs.reg_mr;
|
||||
context_ops->rereg_mr = ibv_context_ops_virt_ptrs.rereg_mr;
|
||||
context_ops->dereg_mr = ibv_context_ops_virt_ptrs.dereg_mr;
|
||||
context_ops->alloc_mw = ibv_context_ops_virt_ptrs.alloc_mw;
|
||||
context_ops->bind_mw = ibv_context_ops_virt_ptrs.bind_mw;
|
||||
context_ops->dealloc_mw = ibv_context_ops_virt_ptrs.dealloc_mw;
|
||||
context_ops->create_cq = ibv_context_ops_virt_ptrs.create_cq;
|
||||
context_ops->poll_cq = ibv_context_ops_virt_ptrs.poll_cq;
|
||||
context_ops->req_notify_cq = ibv_context_ops_virt_ptrs.req_notify_cq;
|
||||
context_ops->cq_event = ibv_context_ops_virt_ptrs.cq_event;
|
||||
context_ops->resize_cq = ibv_context_ops_virt_ptrs.resize_cq;
|
||||
context_ops->destroy_cq = ibv_context_ops_virt_ptrs.destroy_cq;
|
||||
context_ops->create_srq = ibv_context_ops_virt_ptrs.create_srq;
|
||||
context_ops->modify_srq = ibv_context_ops_virt_ptrs.modify_srq;
|
||||
context_ops->query_srq = ibv_context_ops_virt_ptrs.query_srq;
|
||||
context_ops->destroy_srq = ibv_context_ops_virt_ptrs.destroy_srq;
|
||||
context_ops->post_srq_recv = ibv_context_ops_virt_ptrs.post_srq_recv;
|
||||
context_ops->create_qp = ibv_context_ops_virt_ptrs.create_qp;
|
||||
context_ops->query_qp = ibv_context_ops_virt_ptrs.query_qp;
|
||||
context_ops->modify_qp = ibv_context_ops_virt_ptrs.modify_qp;
|
||||
context_ops->destroy_qp = ibv_context_ops_virt_ptrs.destroy_qp;
|
||||
context_ops->post_send = ibv_context_ops_virt_ptrs.post_send;
|
||||
context_ops->post_recv = ibv_context_ops_virt_ptrs.post_recv;
|
||||
context_ops->create_ah = ibv_context_ops_virt_ptrs.create_ah;
|
||||
context_ops->destroy_ah = ibv_context_ops_virt_ptrs.destroy_ah;
|
||||
context_ops->attach_mcast = ibv_context_ops_virt_ptrs.attach_mcast;
|
||||
context_ops->detach_mcast = ibv_context_ops_virt_ptrs.detach_mcast;
|
||||
context_ops->async_event = ibv_context_ops_virt_ptrs.async_event;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_port_attr
|
||||
*/
|
||||
|
||||
struct ibv_port_attr * guest_to_host_ibv_port_attr(struct ibv_port_attr * port_attr) {
|
||||
return (struct ibv_port_attr *) guest_to_host((size_t) port_attr);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_port_attr(struct ibv_port_attr * port_attr) {}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_comp_channel
|
||||
*/
|
||||
|
||||
/* static struct { */
|
||||
/* struct ibv_context * context; */
|
||||
/* } ibv_comp_channel_virt_ptrs; */
|
||||
|
||||
struct ibv_comp_channel * guest_to_host_ibv_comp_channel(struct ibv_comp_channel * channel) {
|
||||
ibv_comp_channel_virt_ptrs.context = channel->context;
|
||||
|
||||
channel->context = guest_to_host_ibv_context(channel->context);
|
||||
|
||||
return (struct ibv_comp_channel *) guest_to_host((size_t) channel);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_comp_channel(struct ibv_comp_channel * channel) {
|
||||
channel->context = ibv_comp_channel_virt_ptrs.context;
|
||||
|
||||
host_to_guest_ibv_context(channel->context);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* struct ibv_abi_compat_v2
|
||||
*/
|
||||
|
||||
struct ibv_abi_compat_v2 * guest_to_host_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat) {
|
||||
guest_to_host_ibv_comp_channel(&abi_compat->channel);
|
||||
guest_to_host_pthread_mutex_t(&abi_compat->in_use);
|
||||
|
||||
return (struct ibv_abi_compat_v2 *) guest_to_host((size_t) abi_compat);
|
||||
}
|
||||
|
||||
void host_to_guest_ibv_abi_compat_v2(struct ibv_abi_compat_v2 * abi_compat) {
|
||||
host_to_guest_ibv_comp_channel(&abi_compat->channel);
|
||||
host_to_guest_pthread_mutex_t(&abi_compat->in_use);
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* pthread_mutex_t
|
||||
*/
|
||||
|
||||
/* static struct { */
|
||||
/* _pthread_descr __m_owner; */
|
||||
/* } pthread_mutex_t_virt_ptrs; */
|
||||
|
||||
pthread_mutex_t * guest_to_host_pthread_mutex_t(pthread_mutex_t * mutex) {
|
||||
pthread_mutex_t_virt_ptrs.__m_owner = mutex->__m_owner; // TODO:
|
||||
|
||||
/* mutex->__m_owner = guest_to_host__pthread_descr(mutex->__m_owner); */
|
||||
|
||||
return (struct pthread_mutex_t *) guest_to_host((size_t) mutex);
|
||||
}
|
||||
|
||||
void host_to_guest_pthread_mutex_t(pthread_mutex_t * mutex) {
|
||||
/* host_to_guest__pthread_descr(mutex->__m_owner); */
|
||||
struct ibv_context_ops * host_to_guest_ibv_context_ops(
|
||||
struct ibv_context_ops * context_ops, addr_type type) {
|
||||
struct ibv_context_ops * vaddr = (type == GUEST) ? context_ops
|
||||
: (struct ibv_context_ops *) host_to_guest((size_t) context_ops);
|
||||
|
||||
context_ops->query_device = (int (*)(struct ibv_context *, struct ibv_device_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->query_port = (int (*)(struct ibv_context *, uint8_t, struct ibv_port_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->alloc_pd = (struct ibv_pd * (*)(struct ibv_context *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->dealloc_pd = (int (*)(struct ibv_pd *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->reg_mr = (struct ibv_mr * (*)(struct ibv_pd *, void *, size_t, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->rereg_mr = (int (*)(struct ibv_mr *, int, struct ibv_pd *, void *, size_t, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->dereg_mr = (int (*)(struct ibv_mr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->alloc_mw = (struct ibv_mw * (*)(struct ibv_pd *, enum ibv_mw_type)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->bind_mw = (int (*)(struct ibv_qp *, struct ibv_mw *, struct ibv_mw_bind *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->dealloc_mw = (int (*)(struct ibv_mw *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->create_cq = (struct ibv_cq * (*)(struct ibv_context *, int, struct ibv_comp_channel *, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->poll_cq = (int (*)(struct ibv_cq *, int, struct ibv_wc *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->req_notify_cq = (int (*)(struct ibv_cq *, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->cq_event = (void (*)(struct ibv_cq *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->resize_cq = (int (*)(struct ibv_cq *, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->destroy_cq = (int (*)(struct ibv_cq *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->create_srq = (struct ibv_srq * (*)(struct ibv_pd *, struct ibv_srq_init_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->modify_srq = (int (*)(struct ibv_srq *, struct ibv_srq_attr *, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->query_srq = (int (*)(struct ibv_srq *, struct ibv_srq_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->destroy_srq = (int (*)(struct ibv_srq *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->post_srq_recv = (int (*)(struct ibv_srq *, struct ibv_recv_wr *, struct ibv_recv_wr **)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->create_qp = (struct ibv_qp * (*)(struct ibv_pd *, struct ibv_qp_init_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->query_qp = (int (*)(struct ibv_qp *, struct ibv_qp_attr *, int, struct ibv_qp_init_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->modify_qp = (int (*)(struct ibv_qp *, struct ibv_qp_attr *, int)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->destroy_qp = (int (*)(struct ibv_qp *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->post_send = (int (*)(struct ibv_qp *, struct ibv_send_wr *, struct ibv_send_wr **)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->post_recv = (int (*)(struct ibv_qp *, struct ibv_recv_wr *, struct ibv_recv_wr **)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->create_ah = (struct ibv_ah * (*)(struct ibv_pd *, struct ibv_ah_attr *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->destroy_ah = (int (*)(struct ibv_ah *)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->attach_mcast = (int (*)(struct ibv_qp *, const union ibv_gid *, uint16_t)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->detach_mcast = (int (*)(struct ibv_qp *, const union ibv_gid *, uint16_t)) host_to_guest((size_t) vaddr->);
|
||||
context_ops->async_event = (void (*)(struct ibv_async_event *)) host_to_guest((size_t) vaddr->);
|
||||
// todo
|
||||
|
||||
|
||||
context_ops->query_device = host_to_guest((size_t) vaddr->query_device);
|
||||
context_ops->query_port = host_to_guest((size_t) vaddr->query_port);
|
||||
context_ops->alloc_pd = host_to_guest((size_t) vaddr->alloc_pd);
|
||||
context_ops->dealloc_pd = host_to_guest((size_t) vaddr->dealloc_pd);
|
||||
context_ops->reg_mr = host_to_guest((size_t) vaddr->reg_mr);
|
||||
context_ops->rereg_mr = host_to_guest((size_t) vaddr->rereg_mr);
|
||||
context_ops->dereg_mr = host_to_guest((size_t) vaddr->dereg_mr);
|
||||
context_ops->alloc_mw = host_to_guest((size_t) vaddr->alloc_mw);
|
||||
context_ops->bind_mw = host_to_guest((size_t) vaddr->bind_mw);
|
||||
context_ops->dealloc_mw = host_to_guest((size_t) vaddr->dealloc_mw);
|
||||
context_ops->create_cq = host_to_guest((size_t) vaddr->create_cq);
|
||||
context_ops->poll_cq = host_to_guest((size_t) vaddr->poll_cq);
|
||||
context_ops->req_notify_cq = host_to_guest((size_t) vaddr->req_notify_cq);
|
||||
context_ops->cq_event = host_to_guest((size_t) vaddr->cq_event);
|
||||
context_ops->resize_cq = host_to_guest((size_t) vaddr->resize_cq);
|
||||
context_ops->destroy_cq = host_to_guest((size_t) vaddr->destroy_cq);
|
||||
context_ops->create_srq = host_to_guest((size_t) vaddr->create_srq);
|
||||
context_ops->modify_srq = host_to_guest((size_t) vaddr->modify_srq);
|
||||
context_ops->query_srq = host_to_guest((size_t) vaddr->query_srq);
|
||||
context_ops->destroy_srq = host_to_guest((size_t) vaddr->destroy_srq);
|
||||
context_ops->post_srq_recv = host_to_guest((size_t) vaddr->post_srq_recv);
|
||||
context_ops->create_qp = host_to_guest((size_t) vaddr->create_qp);
|
||||
context_ops->query_qp = host_to_guest((size_t) vaddr->query_qp);
|
||||
context_ops->modify_qp = host_to_guest((size_t) vaddr->modify_qp);
|
||||
context_ops->destroy_qp = host_to_guest((size_t) vaddr->destroy_qp);
|
||||
context_ops->post_send = host_to_guest((size_t) vaddr->post_send);
|
||||
context_ops->post_recv = host_to_guest((size_t) vaddr->post_recv);
|
||||
context_ops->create_ah = host_to_guest((size_t) vaddr->create_ah);
|
||||
context_ops->destroy_ah = host_to_guest((size_t) vaddr->destroy_ah);
|
||||
context_ops->attach_mcast = host_to_guest((size_t) vaddr->attach_mcast);
|
||||
context_ops->detach_mcast = host_to_guest((size_t) vaddr->detach_mcast);
|
||||
context_ops->async_event = host_to_guest((size_t) vaddr->async_event);
|
||||
|
||||
return vaddr;
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue