From: Sean Hefty Date: Tue, 23 Oct 2012 07:59:59 +0000 (-0700) Subject: refresh (create temporary patch) X-Git-Url: https://openfabrics.org/gitweb/?a=commitdiff_plain;h=bcaaebf3f5830d3c3748466fbd20ef0d9fa81eeb;p=~shefty%2Flibrdmacm.git refresh (create temporary patch) --- diff --git a/meta b/meta index aa49a13d..20ab6639 100644 --- a/meta +++ b/meta @@ -1,8 +1,9 @@ Version: 1 -Previous: bbd4a71ab7ab748798115c05246bab36e487b436 -Head: 4507f7d7d64e24375de21367e59a39665d85e12b +Previous: d2b0428f8aa4a167a53833682c818422982dfe2e +Head: f0fc707aeebfbb6b383d6d5d471310e2a46a004b Applied: rs-iomap: 4507f7d7d64e24375de21367e59a39665d85e12b + refresh-temp: f0fc707aeebfbb6b383d6d5d471310e2a46a004b Unapplied: resv-rs-len: 7b6ff5c4894f54b221d877adcd709795dffb2fe9 rs-target-sgl: 7a07c80f2242e80c076dcf3ec6bb4c94626b284f diff --git a/patches/refresh-temp b/patches/refresh-temp new file mode 100644 index 00000000..71003f0d --- /dev/null +++ b/patches/refresh-temp @@ -0,0 +1,322 @@ +Bottom: 5604b4bc827008a75c9690ec7b8ff3cc77314374 +Top: ea70904deb6e6424cbdeacc9a46e20ee1b29e5c0 +Author: Sean Hefty +Date: 2012-10-23 00:59:59 -0700 + +Refresh of rs-iomap + +--- + +diff --git a/include/rdma/rsocket.h b/include/rdma/rsocket.h +index 65feda9..21477e4 100644 +--- a/include/rdma/rsocket.h ++++ b/include/rdma/rsocket.h +@@ -1,5 +1,5 @@ + /* +- * Copyright (c) 2011 Intel Corporation. All rights reserved. ++ * Copyright (c) 2011-2012 Intel Corporation. All rights reserved. + * + * This software is available to you under a choice of one of two + * licenses. You may choose to be licensed under the terms of the GNU +@@ -85,6 +85,10 @@ int rgetsockopt(int socket, int level, int optname, + void *optval, socklen_t *optlen); + int rfcntl(int socket, int cmd, ... /* arg */ ); + ++off_t riomap(int socket, void *buf, size_t len, int prot, int flags, off_t offset); ++int riounmap(int socket, void *buf, size_t len); ++size_t riowrite(int socket, const void *buf, size_t count, off_t offset, int flags); ++ + #ifdef __cplusplus + } + #endif +diff --git a/src/indexer.h b/src/indexer.h +index 26e7f98..0c5f388 100644 +--- a/src/indexer.h ++++ b/src/indexer.h +@@ -31,6 +31,9 @@ + * + */ + ++#if !defined(INDEXER_H) ++#define INDEXER_H ++ + #if HAVE_CONFIG_H + # include + #endif /* HAVE_CONFIG_H */ +@@ -99,3 +102,43 @@ static inline void *idm_lookup(struct index_map *idm, int index) + return ((index <= IDX_MAX_INDEX) && idm->array[idx_array_index(index)]) ? + idm_at(idm, index) : NULL; + } ++ ++typedef struct _dlist_entry { ++ struct _dlist_entry *next; ++ struct _dlist_entry *prev; ++} dlist_entry; ++ ++static inline void dlist_init(dlist_entry *head) ++{ ++ head->next = head; ++ head->prev = head; ++} ++ ++static inline int dlist_empty(dlist_entry *head) ++{ ++ return head->next == head; ++} ++ ++static inline void dlist_insert_after(dlist_entry *item, dlist_entry *head) ++{ ++ item->next = head->next; ++ item->prev = head; ++ head->next->prev = item; ++ head->next = item; ++} ++ ++static inline void dlist_insert_before(dlist_entry *item, dlist_entry *head) ++{ ++ dlist_insert_after(item, head->prev); ++} ++ ++#define dlist_insert_head dlist_insert_after ++#define dlist_insert_tail dlist_insert_before ++ ++static inline void dlist_remove(dlist_entry *item) ++{ ++ item->prev->next = item->next; ++ item->next->prev = item->prev; ++} ++ ++#endif /* INDEXER_H */ +diff --git a/src/rsocket.c b/src/rsocket.c +index 40d9440..ed708d4 100644 +--- a/src/rsocket.c ++++ b/src/rsocket.c +@@ -59,7 +59,6 @@ + #define RS_QP_CTRL_SIZE 4 + #define RS_CONN_RETRIES 6 + #define RS_SGL_SIZE 2 +-#define RS_MAX_IOMAP 128 + static struct index_map idm; + static pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; + +@@ -118,6 +117,14 @@ struct rs_iomap { + struct rs_sge sge; + }; + ++struct rs_iomap_mr { ++ uint64_t offset; ++ struct ibv_mr *mr; ++ dlist_entry entry; ++ atomic_t refcnt; ++ int index; /* -1 if mapping is local and not in iomap_list */ ++}; ++ + #define RS_MIN_INLINE (sizeof(struct rs_sge)) + #define rs_host_is_net() (1 == htonl(1)) + #define RS_CONN_FLAG_NET (1 << 0) +@@ -164,6 +171,7 @@ struct rsocket { + fastlock_t rlock; + fastlock_t cq_lock; + fastlock_t cq_wait_lock; ++ fastlock_t iomap_lock; + + int opts; + long fd_flags; +@@ -196,7 +204,11 @@ struct rsocket { + int remote_sge; + struct rs_sge remote_sgl; + struct rs_sge remote_iomap; +- struct rs_iomap *remote_iomappings; ++ ++ struct rs_iomap_mr *remote_iomappings; ++ dlist_entry iomap_list; ++ dlist_entry iomap_queue; ++ int iomap_pending; + + struct ibv_mr *target_mr; + int target_sge; +@@ -336,6 +348,9 @@ static struct rsocket *rs_alloc(struct rsocket *inherited_rs) + fastlock_init(&rs->rlock); + fastlock_init(&rs->cq_lock); + fastlock_init(&rs->cq_wait_lock); ++ fastlock_init(&rs->iomap_lock); ++ dlist_init(&rs->iomap_list); ++ dlist_init(&rs->iomap_queue); + return rs; + } + +@@ -501,6 +516,42 @@ static int rs_create_ep(struct rsocket *rs) + return 0; + } + ++/* ++static xxx rs_acquire_iomap_mr(struct rsocket *rs, ...) ++{ ++ TODO: write me ++} ++*/ ++ ++static void rs_release_iomap_mr(struct rs_iomap_mr *iomr) ++{ ++ if (atomic_dec(&iomr->refcnt)) ++ return; ++ ++ dlist_remove(&iomr->entry); ++ ibv_dereg_mr(iomr->mr); ++ if (iomr->index >= 0) ++ iomr->mr = NULL; ++ else ++ free(iomr); ++} ++ ++static void rs_free_iomappings(struct rsocket *rs) ++{ ++ struct rs_iomap_mr *iomr; ++ ++ while (!dlist_empty(&rs->iomap_list)) { ++ iomr = container_of(rs->iomap_list.next, ++ struct rs_iomap_mr, entry); ++ riounmap(iomr->mr->addr, iomr->mr->length); ++ } ++ while (!dlist_empty(&rs->iomap_queue)) { ++ iomr = container_of(rs->iomap_queue.next, ++ struct rs_iomap_mr, entry); ++ riounmap(iomr->mr->addr, iomr->mr->length); ++ } ++} ++ + static void rs_free(struct rsocket *rs) + { + if (rs->index >= 0) +@@ -528,11 +579,13 @@ static void rs_free(struct rsocket *rs) + } + + if (rs->cm_id) { ++ rs_free_iomappings(rs); + if (rs->cm_id->qp) + rdma_destroy_qp(rs->cm_id); + rdma_destroy_id(rs->cm_id); + } + ++ fastlock_destroy(&rs->iomap_lock); + fastlock_destroy(&rs->cq_wait_lock); + fastlock_destroy(&rs->cq_lock); + fastlock_destroy(&rs->rlock); +@@ -2081,3 +2134,117 @@ int rfcntl(int socket, int cmd, ... /* arg */ ) + va_end(args); + return ret; + } ++ ++static struct rs_iomap_mr *rs_get_iomap_mr(struct rsocket *rs) ++{ ++ struct rs_iomap_mr *iomr; ++ int i; ++ ++ if (!rs->remote_iomappings) { ++ rs->remote_iomappings = calloc(rs->remote_iomap.length, ++ sizeof(*rs->remote_iomappings)); ++ if (!rs->remote_iomappings) ++ return NULL; ++ ++ for (i = 0; i < rs->remote_iomap.length; i++) ++ rs->remote_iomappings[i].index = i; ++ } ++ ++ for (i = 0; i < rs->remote_iomap.length; i++) { ++ if (!rs->remote_iomappings[i]->mr) ++ return &rs->remote_iomappings[i]; ++ } ++ return NULL; ++} ++ ++/* ++ * If an offset is given, we map to it. If offset is -1, then we map the ++ * offset to the address of buf. We do not check for conflicts, which must ++ * be fixed at some point. ++ */ ++off_t riomap(int socket, void *buf, size_t len, int prot, int flags, off_t offset) ++{ ++ struct rsocket *rs; ++ struct rs_iomap_mr *iomr; ++ int ret, access = IBV_ACCESS_LOCAL_WRITE; ++ ++ rs = idm_at(&idm, socket); ++ if ((rs->state != rs_connect_rdwr) || (prot & ~(PROT_WRITE | PROT_NONE))) ++ return ERR(EINVAL); ++ ++ fastlock_acquire(&rs->iomap_lock); ++ if (prot & PROT_WRITE) { ++ iomr = rs_get_iomap_mr(rs); ++ access |= IBV_ACCESS_REMOTE_WRITE; ++ } else { ++ iomr = calloc(1, sizeof *iomr); ++ iomr->index = -1; ++ } ++ if (!iomr) { ++ offset = ERR(ENOMEM); ++ goto out; ++ } ++ ++ iomr->mr = ibv_reg_mr(rs->cm_id->pd, buf, len, access); ++ if (!iomr->mr) { ++ if (iomr->index < 0) ++ free(iomr); ++ offset = -1; ++ goto out; ++ } ++ ++ if (offset == -1) ++ offset = (uintptr_t) buf; ++ iomr->offset = offset; ++ iomr->prot = prot; ++ atomic_init(&iomr->refcnt); ++ atomic_set(&iomr->refcnt, 1); ++ ++ if (iomr->index >= 0) { ++ dlist_insert_tail(&iomr->entry, &rs->iomap_queue); ++ rs->iomap_pending = 1; ++ } else { ++ dlist_insert_tail(&iomr->entry, &rs->iomap_list); ++ } ++out: ++ fastlock_release(&rs->iomap_lock); ++ return offset; ++} ++ ++int riounmap(int socket, void *buf, size_t len) ++{ ++ struct rsocket *rs; ++ struct rs_iomap_mr *iomr; ++ struct dlist_entry *entry; ++ int ret = 0; ++ ++ rs = idm_at(&idm, socket); ++ fastlock_acquire(&rs->iomap_lock); ++ ++ for (entry = rs->iomap_list.next; entry != &rs->iomap_list; ++ entry = entry->next) { ++ iomr = container_of(entry, struct rs_iomap_mr, entry); ++ if (iomr->mr->addr == buf && iomr->mr->length == len) { ++ rs_release_iomap_mr(iomr); ++ goto out; ++ } ++ } ++ ++ for (entry = rs->iomap_queue.next; entry != &rs->iomap_queue; ++ entry = entry->next) { ++ iomr = container_of(entry, struct rs_iomap_mr, entry); ++ if (iomr->mr->addr == buf && iomr->mr->length == len) { ++ rs_release_iomap_mr(iomr); ++ goto out; ++ } ++ } ++ ret = ERR(EINVAL); ++out: ++ fastlock_release(&rs->iomap_lock); ++ return ret; ++} ++ ++size_t riowrite(int socket, const void *buf, size_t count, off_t offset, int flags) ++{ ++ ++}