diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/kiro-client.c | 26 | ||||
| -rw-r--r-- | src/kiro-client.h | 93 | ||||
| -rw-r--r-- | src/kiro-rdma.h | 2 | ||||
| -rw-r--r-- | src/kiro-server.c | 13 | ||||
| -rw-r--r-- | src/kiro-server.h | 35 | ||||
| -rw-r--r-- | src/kiro-trb.h | 25 |
6 files changed, 173 insertions, 21 deletions
diff --git a/src/kiro-client.c b/src/kiro-client.c index 12d4a45..8fa582b 100644 --- a/src/kiro-client.c +++ b/src/kiro-client.c @@ -85,6 +85,9 @@ kiro_client_init (KiroClient *self) { KiroClientPrivate *priv = KIRO_CLIENT_GET_PRIVATE (self); memset (priv, 0, sizeof (&priv)); + + //Hack to make the 'unused function' from the kiro-rdma include go away... + kiro_attach_qp (NULL); } @@ -118,10 +121,15 @@ kiro_client_connect (KiroClient *self, const char *address, const char *port) struct rdma_addrinfo hints, *res_addrinfo; memset (&hints, 0, sizeof (hints)); - hints.ai_port_space = RDMA_PS_IB; - if (rdma_getaddrinfo (address, port, &hints, &res_addrinfo)) { + char *addr_c = g_strdup (address); + char *port_c = g_strdup (port); + int rtn = rdma_getaddrinfo (addr_c, port_c, &hints, &res_addrinfo); + g_free (addr_c); + g_free (port_c); + + if (rtn) { g_critical ("Failed to get address information for %s:%s : %s", address, port, strerror (errno)); return -1; } @@ -200,7 +208,7 @@ kiro_client_connect (KiroClient *self, const char *address, const char *port) g_debug ("Got RDMI Access information from Server"); ctx->peer_mr = (((struct kiro_ctrl_msg *) (ctx->cf_mr_recv->mem))->peer_mri); - g_debug ("Expected Memory Size is: %u", ctx->peer_mr.length); + g_debug ("Expected Memory Size is: %zu", ctx->peer_mr.length); ctx->rdma_mr = kiro_create_rdma_memory (priv->conn->pd, ctx->peer_mr.length, IBV_ACCESS_LOCAL_WRITE); if (!ctx->rdma_mr) { @@ -228,12 +236,9 @@ kiro_client_sync (KiroClient *self) struct kiro_connection_context *ctx = (struct kiro_connection_context *)priv->conn->context; - if (rdma_post_read (priv->conn, priv->conn, ctx->rdma_mr->mem, ctx->peer_mr.length, ctx->rdma_mr->mr, 0, ctx->peer_mr.addr, ctx->peer_mr.rkey)) { + if (rdma_post_read (priv->conn, priv->conn, ctx->rdma_mr->mem, ctx->peer_mr.length, ctx->rdma_mr->mr, 0, (uint64_t)ctx->peer_mr.addr, ctx->peer_mr.rkey)) { g_critical ("Failed to RDMA_READ from server: %s", strerror (errno)); - rdma_disconnect (priv->conn); - kiro_destroy_connection_context (&ctx); - rdma_destroy_ep (priv->conn); - return -1; + goto fail; } struct ibv_wc wc; @@ -257,10 +262,7 @@ kiro_client_sync (KiroClient *self) } fail: - rdma_disconnect (priv->conn); - kiro_destroy_connection_context (&ctx); - rdma_destroy_ep (priv->conn); - priv->conn = NULL; + kiro_destroy_connection (&(priv->conn)); return -1; } diff --git a/src/kiro-client.h b/src/kiro-client.h index 8e99877..9e9d3ef 100644 --- a/src/kiro-client.h +++ b/src/kiro-client.h @@ -70,20 +70,111 @@ struct _KiroClientClass { /* GObject and GType functions */ +/** + * kiro_client_get_type: (skip) + * Returns: GType of #KiroClient + */ GType kiro_client_get_type (void); +/** + * kiro_client_new - Creates a new #KiroClient + * Returns: (transfer full): A pointer to a new #KiroClient + * Description: + * Creates a new, unconnected #KiroClient and returns a pointer to it. + * See also: + * kiro_client_free, kiro_client_connect + */ KiroClient* kiro_client_new (void); +/** + * kiro_client_free - 'Destroys' the given #KiroClient + * @client: (transfer none): The #KiroClient that is to be freed + * Description: + * Transitions the #KiroServer through all necessary shutdown routines and + * frees the object memory. + * Note: + * The memory content that has been transfered from the server is + * automatically freed when calling this function. If you want to continue + * using the memory after freeing the #KiroClient, make sure to memcpy() it + * first, using the informations obtained from kiro_client_get_memory() and + * kiro_client_get_memory_size(). + * See also: + * kiro_client_new, kiro_client_connect + */ void kiro_client_free (KiroClient *client); /* client functions */ + +/** + * kiro_client_connect - Connect a #KiroClient to a Server + * @client: (transfer none): The #KiroClient to connect + * @dest_addr: (transfer none): The address of the target server + * @dest_port: (transfer none): The port of the target server + * Returns: + * 0 if the connection was successful, -1 in case of connection error + * Description: + * Connects the given #KiroClient to a KIRO server described by @dest_addr and + * @dest_port. + * Note: + * When building a connection to the server, memory for the transmission is + * created as well. + * See also: + * kiro_server_new + */ int kiro_client_connect (KiroClient *client, const char *dest_addr, const char *dest_port); +/** + * kiro_client_sync - Read data from the connected server + * @client: (transfer none): The #KiroServer to use sync on + * Returns: + * 0 if successful, -1 in case of synchronisation error + * Description: + * This synchronizes the client with the server, clining the memory + * provided by the server to the local client. The memory can be accessed by + * using kiro_client_get_memory(). + * Note: + * The server can send a 'reallocation' request to the client, forcing it to + * reallocate new memory with the next occurrence of kiro_client_sync(), + * freeing the old memory in the process. + *See also: + * kiro_client_get_memory, kiro_cient_connect + */ int kiro_client_sync (KiroClient *client); -void *kiro_client_get_memory (KiroClient *client); +/** + * kiro_client_get_memory - Return a pointer to the current client memory + * @client: (transfer none): The #KiroClient to get the memory from + * Returns: (transfer none): + * A pointer to the current memory of the client. + * Note: + * The server can instruct the client to reallocate memory on the next + * occurrence of kiro_client_sync(), freeing the old memory. Also, calling + * kiro_client_free() will free the client memory as well. If you need to + * make sure that the memory from the @client remains accessible after + * calling sync and/or free, you need to memcpy() the memory using the + * information from kiro_client_get_memory() and + * kiro_client_get_memory_size() first. + * The returned memory might under NO circumstances be freed by the user! + * See also: + * kiro_client_get_memory_size, kiro_client_sync + */ +void* kiro_client_get_memory (KiroClient *client); +/** + * kiro_client_get_memory_size - Return the client memory size in bytes + * @client: (transfer none): The #KiroClient to get the memory size of + * Returns: + * The size of the given #KiroClient memory in bytes + * Description: + * Returns the size of the allocated memory of @client, in bytes. + * Note: + * The server can instruct the client to reallocate memroy on the next + * occurrence of kiro_server_sync(), freeing the old memory. This might also + * effect the respective memory size. + * See also: + * kiro_client_get_memory, kiro_client_sync + */ size_t kiro_client_get_memory_size (KiroClient *client); G_END_DECLS diff --git a/src/kiro-rdma.h b/src/kiro-rdma.h index 9a3cbe8..af502ec 100644 --- a/src/kiro-rdma.h +++ b/src/kiro-rdma.h @@ -81,7 +81,7 @@ kiro_attach_qp (struct rdma_cm_id *id) id->recv_cq = id->send_cq; //we use one shared completion queue struct ibv_qp_init_attr qp_attr; memset (&qp_attr, 0, sizeof (struct ibv_qp_init_attr)); - qp_attr.qp_context = (uintptr_t)id; + qp_attr.qp_context = (void *) (uintptr_t) id; qp_attr.send_cq = id->send_cq; qp_attr.recv_cq = id->recv_cq; qp_attr.qp_type = IBV_QPT_RC; diff --git a/src/kiro-server.c b/src/kiro-server.c index b3c8516..91c86ec 100644 --- a/src/kiro-server.c +++ b/src/kiro-server.c @@ -288,7 +288,7 @@ event_loop (void *self) int -kiro_server_start (KiroServer *self, char *address, char *port, void *mem, size_t mem_size) +kiro_server_start (KiroServer *self, const char *address, const char *port, void *mem, size_t mem_size) { KiroServerPrivate *priv = KIRO_SERVER_GET_PRIVATE (self); @@ -307,7 +307,14 @@ kiro_server_start (KiroServer *self, char *address, char *port, void *mem, size_ hints.ai_port_space = RDMA_PS_IB; hints.ai_flags = RAI_PASSIVE; - if (rdma_getaddrinfo (address, port, &hints, &res_addrinfo)) { + char *addr_c = g_strdup (address); + char *port_c = g_strdup (port); + + int rtn = rdma_getaddrinfo (addr_c, port_c, &hints, &res_addrinfo); + g_free (addr_c); + g_free (port_c); + + if (rtn) { g_critical ("Failed to create address information: %s", strerror (errno)); return -1; } @@ -371,6 +378,8 @@ kiro_server_start (KiroServer *self, char *address, char *port, void *mem, size_ static void disconnect_client (gpointer data, gpointer user_data) { + (void)user_data; + if (data) { struct rdma_cm_id *id = (struct rdma_cm_id *)data; struct kiro_connection_context *ctx = (struct kiro_connection_context *) (id->context); diff --git a/src/kiro-server.h b/src/kiro-server.h index 78b2cf4..7e42159 100644 --- a/src/kiro-server.h +++ b/src/kiro-server.h @@ -70,10 +70,36 @@ struct _KiroServerClass { /* GObject and GType functions */ + +/** + * kiro_server_get_type: (skip) + * Returns: GType of KiroServer + */ GType kiro_server_get_type (void); -KiroServer *kiro_server_new (void); +/** + * kiro_server_new - Creates a new #KiroServer + * Returns: (transfer full): A pointer to a new #KiroServer + * Description: + * Creates a new, unbound #KiroServer and returns a pointer to it. + * See also: + * kiro_server_start, kiro_server_free + */ +KiroServer* kiro_server_new (void); +/** + * kiro_server_free - 'Destroys' the given #KiroServer + * @server: The #KiroServer that is to be freed + * Description: + * Transitions the #KiroServer through all necessary shutdown routines and + * frees the object memory. + * Note: + * The memory that is given to the server when calling kiro_server_start will + * NOT be freed! The user is responsible to free this memory, if no longer + * needed. + * See also: + * kiro_server_start, kiro_server_new + */ void kiro_server_free (KiroServer *server); @@ -84,7 +110,7 @@ void kiro_server_free (KiroServer *server); * @server: #KiroServer to perform the operation on * @bind_addr: Local address to bind the server to * @bind_port: Local port to listen for connections - * @mem: Pointer to the memory that is to be provided + * @mem: (transfer none): Pointer to the memory that is to be provided * @mem_size: Size in bytes of the given memory * Description: * Starts the #KiroServer to provide the given memory to any connecting @@ -99,10 +125,9 @@ void kiro_server_free (KiroServer *server); * and return the chosen port as return value. * If server creation fails, -1 is returned instead. * See also: - * kiro_trb_reshape, kiro_trb_adopt, - * kiro_trb_clone + * kiro_server_new, */ -int kiro_server_start (KiroServer *server, char *bind_addr, char *bind_port, void *mem, size_t mem_size); +int kiro_server_start (KiroServer *server, const char *bind_addr, const char *bind_port, void *mem, size_t mem_size); /** * kiro_server_stop - Stops the server diff --git a/src/kiro-trb.h b/src/kiro-trb.h index ff8d418..806ad5e 100644 --- a/src/kiro-trb.h +++ b/src/kiro-trb.h @@ -78,10 +78,35 @@ struct KiroTrbInfo { /* GObject and GType functions */ +/** + * kiro_trb_get_type: (skip) + * Returns: GType of #KiroTrb + */ GType kiro_trb_get_type (void); +/** + * kiro_trb_new - Creates a new #KiroTrb + * Returns: (transfer full): A pointer to a new #KiroTrb + * Description: + * Creates a new, unshaped #KiroTrb and returns a pointer to it. + * See also: + * kiro_trb_free, kiro_trb_reshape + */ KiroTrb* kiro_trb_new (void); +/** + * kiro_trb_free - 'Destroys' the given #KiroTrb + * @trb: (transfer none): The #KiroTrb that is to be freed + * Description: + * Clears all underlying memory and frees the object memory. + * Note: + * The internal memory is also freed when calling this function. If you want + * to continue using the raw @trb memory after call this function, you need to + * memcpy() its content using the information optained from + * kiro_trb_get_raw_buffer and kiro_trb_get_raw_size. + * See also: + * kiro_trb_new + */ void kiro_trb_free (KiroTrb *trb); |