From 8c16a15f6e95715f3f4632e59632406bb86013e5 Mon Sep 17 00:00:00 2001 From: Sean Hefty Date: Thu, 30 Jun 2011 10:46:21 -0700 Subject: [PATCH] refresh (create temporary patch) --- meta | 5 +- patches/refresh-temp | 387 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 390 insertions(+), 2 deletions(-) create mode 100644 patches/refresh-temp diff --git a/meta b/meta index 99d2177..5d0edd5 100644 --- a/meta +++ b/meta @@ -1,11 +1,12 @@ Version: 1 -Previous: db35396b1fb9e12891ced4ad6e0274c3d811516b -Head: 0749c0f5848c4477285e26f8fac372ca5398a620 +Previous: b671e707f29316f8baf6c5f8f35201d06285fa2c +Head: 05cb64641f228c6917d019479b190a8d620dc778 Applied: deam: 3eb8f395f9a52f04c5b408812e743566e6d673fe braces: b6e7734ccc3d5e6103ae137025ec71b6bea39a63 counters: 50c4373f67227780faa494f4a92867239aaaf2f1 alias: 0749c0f5848c4477285e26f8fac372ca5398a620 + refresh-temp: 05cb64641f228c6917d019479b190a8d620dc778 Unapplied: bldwrn: 754494566259b4da96d1c3d64c836d0fd45c4861 acm1.0.5: 1b225173756cfcec4d81d26b1160ebae7644261b diff --git a/patches/refresh-temp b/patches/refresh-temp new file mode 100644 index 0000000..38426fa --- /dev/null +++ b/patches/refresh-temp @@ -0,0 +1,387 @@ +Bottom: 8864809ef6d9a80d56580e120464fdf278ae6418 +Top: 722034575c4d25b55cfc2359502f5ed5399512a7 +Author: Sean Hefty +Date: 2011-06-30 10:46:21 -0700 + +Refresh of alias + +--- + +diff --git a/src/acm.c b/src/acm.c +index 2b77081..7ae6938 100644 +--- a/src/acm.c ++++ b/src/acm.c +@@ -181,6 +181,12 @@ struct acm_request { + struct acm_msg msg; + }; + ++union socket_addr { ++ struct sockaddr sa; ++ struct sockaddr_in sin; ++ struct sockaddr_in6 sin6; ++}; ++ + static DLIST_ENTRY dev_list; + + static atomic_t tid; +@@ -403,7 +409,7 @@ static void acm_release_sa_dest(struct acm_dest *dest) + //} + + static struct acm_request * +-acm_alloc_req(struct acm_client *client, struct acm_msg *msg) ++acm_alloc_req(struct acm_client *client, struct acm_resolve_msg *msg) + { + struct acm_request *req; + +@@ -999,10 +1005,11 @@ acm_send_addr_resp(struct acm_ep *ep, struct acm_dest *dest) + } + + static int +-acm_client_resolve_resp(struct acm_client *client, struct acm_msg *req_msg, ++acm_client_resolve_resp(struct acm_client *client, struct acm_resolve_msg *req_msg, + struct acm_dest *dest, uint8_t status) + { + struct acm_msg msg; ++ struct acm_resolve_msg *resp_msg = (struct acm_resolve_msg *) &msg; + int ret; + + acm_log(2, "client %d, status 0x%x\n", client->index, status); +@@ -1020,28 +1027,28 @@ acm_client_resolve_resp(struct acm_client *client, struct acm_msg *req_msg, + goto release; + } + +- msg.hdr = req_msg->hdr; +- msg.hdr.opcode |= ACM_OP_ACK; +- msg.hdr.status = status; +- msg.hdr.length = ACM_MSG_HDR_LENGTH; +- memset(msg.hdr.data, 0, sizeof(msg.hdr.data)); ++ resp_msg->hdr = req_msg->hdr; ++ resp_msg->hdr.opcode |= ACM_OP_ACK; ++ resp_msg->hdr.status = status; ++ resp_msg->hdr.length = ACM_MSG_HDR_LENGTH; ++ memset(resp_msg->hdr.data, 0, sizeof(resp_msg->hdr.data)); + + if (status == ACM_STATUS_SUCCESS) { +- msg.hdr.length += ACM_MSG_EP_LENGTH; +- msg.resolve_data[0].flags = IBV_PATH_FLAG_GMP | ++ resp_msg->hdr.length += ACM_MSG_EP_LENGTH; ++ resp_msg->data[0].flags = IBV_PATH_FLAG_GMP | + IBV_PATH_FLAG_PRIMARY | IBV_PATH_FLAG_BIDIRECTIONAL; +- msg.resolve_data[0].type = ACM_EP_INFO_PATH; +- msg.resolve_data[0].info.path = dest->path; ++ resp_msg->data[0].type = ACM_EP_INFO_PATH; ++ resp_msg->data[0].info.path = dest->path; + + if (req_msg->hdr.src_out) { +- msg.hdr.length += ACM_MSG_EP_LENGTH; +- memcpy(&msg.resolve_data[1], &msg.resolve_data[req_msg->hdr.src_out], ++ resp_msg->hdr.length += ACM_MSG_EP_LENGTH; ++ memcpy(&resp_msg->data[1], &req_msg->data[req_msg->hdr.src_out], + ACM_MSG_EP_LENGTH); + } + } + +- ret = send(client->sock, (char *) &msg, msg.hdr.length, 0); +- if (ret != msg.hdr.length) ++ ret = send(client->sock, (char *) resp_msg, resp_msg->hdr.length, 0); ++ if (ret != resp_msg->hdr.length) + acm_log(0, "ERROR - failed to send response\n"); + else + ret = 0; +@@ -1066,7 +1073,8 @@ acm_complete_queued_req(struct acm_dest *dest, uint8_t status) + lock_release(&dest->lock); + + acm_log(2, "completing request, client %d\n", req->client->index); +- acm_client_resolve_resp(req->client, &req->msg, dest, status); ++ acm_client_resolve_resp(req->client, ++ (struct acm_resolve_msg *) &req->msg, dest, status); + acm_free_req(req); + + lock_acquire(&dest->lock); +@@ -1277,7 +1285,8 @@ static void acm_process_acm_recv(struct acm_ep *ep, struct ibv_wc *wc, struct ac + } + + static int +-acm_client_query_resp(struct acm_client *client, struct acm_msg *msg, uint8_t status) ++acm_client_query_resp(struct acm_client *client, ++ struct acm_resolve_msg *msg, uint8_t status) + { + int ret; + +@@ -1307,19 +1316,20 @@ static void + acm_client_sa_resp(struct acm_send_msg *msg, struct ibv_wc *wc, struct acm_mad *mad) + { + struct acm_request *req = (struct acm_request *) msg->context; ++ struct acm_resolve_msg *client_req = (struct acm_resolve_msg *) &req->msg; + struct ib_sa_mad *sa_mad = (struct ib_sa_mad *) mad; + uint8_t status; + + if (mad) { + status = (uint8_t) (ntohs(sa_mad->status) >> 8); +- memcpy(&req->msg.resolve_data[0].info.path, sa_mad->data, ++ memcpy(&client_req->data[0].info.path, sa_mad->data, + sizeof(struct ibv_path_record)); + } else { + status = ACM_STATUS_ETIMEDOUT; + } + acm_log(2, "status 0x%x\n", status); + +- acm_client_query_resp(req->client, &req->msg, status); ++ acm_client_query_resp(req->client, client_req, status); + acm_free_req(req); + } + +@@ -1805,7 +1815,7 @@ acm_get_ep(struct acm_ep_addr_data *data) + } + + static int +-acm_svr_query_path(struct acm_client *client, struct acm_msg *msg) ++acm_svr_query_path(struct acm_client *client, struct acm_resolve_msg *msg) + { + struct acm_request *req; + struct acm_send_msg *sa_msg; +@@ -1820,7 +1830,7 @@ acm_svr_query_path(struct acm_client *client, struct acm_msg *msg) + goto resp; + } + +- ep = acm_get_ep(&msg->resolve_data[0]); ++ ep = acm_get_ep(&msg->data[0]); + if (!ep) { + acm_log(1, "notice - could not find local end point\n"); + status = ACM_STATUS_ESRCADDR; +@@ -1851,8 +1861,8 @@ acm_svr_query_path(struct acm_client *client, struct acm_msg *msg) + mad = (struct ib_sa_mad *) sa_msg->data; + acm_init_path_query(mad); + +- memcpy(mad->data, &msg->resolve_data[0].info.path, sizeof(struct ibv_path_record)); +- mad->comp_mask = acm_path_comp_mask(&msg->resolve_data[0].info.path); ++ memcpy(mad->data, &msg->data[0].info.path, sizeof(struct ibv_path_record)); ++ mad->comp_mask = acm_path_comp_mask(&msg->data[0].info.path); + + atomic_inc(&counter[ACM_CNTR_ROUTE_QUERY]); + acm_post_send(&ep->sa_queue, sa_msg); +@@ -1910,7 +1920,7 @@ acm_send_resolve(struct acm_ep *ep, struct acm_dest *dest, + + static int acm_svr_select_src(struct acm_ep_addr_data *src, struct acm_ep_addr_data *dst) + { +- struct sockaddr_in6 addr; ++ struct socket_addr addr; + socklen_t len; + int ret; + SOCKET s; +@@ -1922,13 +1932,13 @@ static int acm_svr_select_src(struct acm_ep_addr_data *src, struct acm_ep_addr_d + memset(&addr, 0, sizeof addr); + switch (dst->type) { + case ACM_EP_INFO_ADDRESS_IP: +- ((struct sockaddr_in *) &addr)->sin_family = AF_INET; +- memcpy(&((struct sockaddr_in *) &addr)->sin_addr, dst->info.addr, 4); ++ addr.sin.sin_family = AF_INET; ++ memcpy(&addr.sin.sin_addr, dst->info.addr, 4); + len = sizeof(struct sockaddr_in); + break; + case ACM_EP_INFO_ADDRESS_IP6: +- addr.sin6_family = AF_INET6; +- memcpy(&addr.sin6_addr, dst->info.addr, 16); ++ addr.sin.sin6_family = AF_INET6; ++ memcpy(&addr.sin6.sin6_addr, dst->info.addr, 16); + len = sizeof(struct sockaddr_in6); + break; + default: +@@ -1936,20 +1946,20 @@ static int acm_svr_select_src(struct acm_ep_addr_data *src, struct acm_ep_addr_d + return ACM_STATUS_EDESTTYPE; + } + +- s = socket(addr.sin6_family, SOCK_DGRAM, IPPROTO_UDP); ++ s = socket(addr.sa.sa_family, SOCK_DGRAM, IPPROTO_UDP); + if (s == INVALID_SOCKET) { + acm_log(0, "ERROR - unable to allocate socket\n"); + return socket_errno(); + } + +- ret = connect(s, &addr, len); ++ ret = connect(s, &addr.sa, len); + if (ret) { + acm_log(0, "ERROR - unable to connect socket\n"); + ret = socket_errno(); + goto out; + } + +- ret = getsockname(s, &addr, &len); ++ ret = getsockname(s, &addr.sa, &len); + if (ret) { + acm_log(0, "ERROR - failed to get socket address\n"); + ret = socket_errno(); +@@ -1959,9 +1969,9 @@ static int acm_svr_select_src(struct acm_ep_addr_data *src, struct acm_ep_addr_d + src->type = dst->type; + src->flags = ACM_EP_FLAG_SOURCE; + if (dst->type == ACM_EP_INFO_ADDRESS_IP) { +- memcpy(&src->info.addr, &((struct sockaddr_in *) &addr)->sin_addr, 4); ++ memcpy(&src->info.addr, &addr.sin.sin_addr, 4); + } else { +- memcpy(&src->info.addr, &((struct sockaddr_in6 *) &addr)->sin6_addr, 16); ++ memcpy(&src->info.addr, &addr.sin6.sin6_addr, 16); + } + out: + close(s); +@@ -1976,7 +1986,7 @@ out: + * and we'll resolve a source address later. + */ + static uint8_t +-acm_svr_verify_resolve(struct acm_msg *msg, ++acm_svr_verify_resolve(struct acm_resolve_msg *msg, + struct acm_ep_addr_data **saddr, struct acm_ep_addr_data **daddr) + { + struct acm_ep_addr_data *src = NULL, *dst = NULL; +@@ -1989,29 +1999,27 @@ acm_svr_verify_resolve(struct acm_msg *msg, + + cnt = (msg->hdr.length - ACM_MSG_HDR_LENGTH) / ACM_MSG_EP_LENGTH; + for (i = 0; i < cnt; i++) { +- if (msg->resolve_data[i].flags & ACM_EP_FLAG_SOURCE) { ++ if (msg->data[i].flags & ACM_EP_FLAG_SOURCE) { + if (src) { + acm_log(0, "ERROR - multiple sources specified\n"); + return ACM_STATUS_ESRCADDR; + } +- if (!msg->resolve_data[i].type || +- (msg->resolve_data[i].type >= ACM_ADDRESS_RESERVED)) { ++ if (!msg->data[i].type || (msg->data[i].type >= ACM_ADDRESS_RESERVED)) { + acm_log(0, "ERROR - unsupported source address type\n"); + return ACM_STATUS_ESRCTYPE; + } +- src = &msg->resolve_data[i]; ++ src = &msg->data[i]; + } +- if (msg->resolve_data[i].flags & ACM_EP_FLAG_DEST) { ++ if (msg->data[i].flags & ACM_EP_FLAG_DEST) { + if (dst) { + acm_log(0, "ERROR - multiple destinations specified\n"); + return ACM_STATUS_EDESTADDR; + } +- if (!msg->resolve_data[i].type || +- (msg->resolve_data[i].type >= ACM_ADDRESS_RESERVED)) { ++ if (!msg->data[i].type || (msg->data[i].type >= ACM_ADDRESS_RESERVED)) { + acm_log(0, "ERROR - unsupported destination address type\n"); + return ACM_STATUS_EDESTTYPE; + } +- dst = &msg->resolve_data[i]; ++ dst = &msg->data[i]; + } + } + +@@ -2022,7 +2030,7 @@ acm_svr_verify_resolve(struct acm_msg *msg, + + if (!src) { + msg->hdr.src_out = i; +- src = &msg->resolve_data[i]; ++ src = &msg->data[i]; + memset(src, 0, sizeof *src); + } + *saddr = src; +@@ -2033,7 +2041,7 @@ acm_svr_verify_resolve(struct acm_msg *msg, + /* Caller must hold dest lock */ + static uint8_t + acm_svr_queue_req(struct acm_dest *dest, struct acm_client *client, +- struct acm_msg *msg) ++ struct acm_resolve_msg *msg) + { + struct acm_request *req; + +@@ -2048,7 +2056,7 @@ acm_svr_queue_req(struct acm_dest *dest, struct acm_client *client, + } + + static int +-acm_svr_resolve_dest(struct acm_client *client, struct acm_msg *msg) ++acm_svr_resolve_dest(struct acm_client *client, struct acm_resolve_msg *msg) + { + struct acm_ep *ep; + struct acm_dest *dest; +@@ -2139,7 +2147,7 @@ put: + * lookup the destination by either LID or GID. + */ + static int +-acm_svr_resolve_path(struct acm_client *client, struct acm_msg *msg) ++acm_svr_resolve_path(struct acm_client *client, struct acm_resolve_msg *msg) + { + struct acm_ep *ep; + struct acm_dest *dest; +@@ -2154,22 +2162,22 @@ acm_svr_resolve_path(struct acm_client *client, struct acm_msg *msg) + return acm_client_resolve_resp(client, msg, NULL, ACM_STATUS_EINVAL); + } + +- path = &msg->resolve_data[0].info.path; ++ path = &msg->data[0].info.path; + if (!path->dlid && ib_any_gid(&path->dgid)) { + acm_log(0, "notice - no destination specified\n"); + return acm_client_resolve_resp(client, msg, NULL, ACM_STATUS_EDESTADDR); + } + + acm_format_name(2, log_data, sizeof log_data, +- ACM_EP_INFO_PATH, msg->resolve_data[0].info.addr, sizeof *path); ++ ACM_EP_INFO_PATH, msg->data[0].info.addr, sizeof *path); + acm_log(2, "path %s\n", log_data); +- ep = acm_get_ep(&msg->resolve_data[0]); ++ ep = acm_get_ep(&msg->data[0]); + if (!ep) { + acm_log(0, "notice - unknown local end point\n"); + return acm_client_resolve_resp(client, msg, NULL, ACM_STATUS_ESRCADDR); + } + +- addr = msg->resolve_data[1].info.addr; ++ addr = msg->data[1].info.addr; + memset(addr, 0, ACM_MAX_ADDRESS); + if (path->dlid) { + * ((uint16_t *) addr) = path->dlid; +@@ -2202,7 +2210,7 @@ acm_svr_resolve_path(struct acm_client *client, struct acm_msg *msg) + } + /* fall through */ + default: +- if (msg->resolve_data[0].flags & ACM_FLAGS_NODELAY) { ++ if (msg->data[0].flags & ACM_FLAGS_NODELAY) { + acm_log(2, "lookup initiated, but client wants no delay\n"); + status = ACM_STATUS_ENODATA; + break; +@@ -2222,10 +2230,10 @@ put: + return ret; + } + +-static int acm_svr_resolve(struct acm_client *client, struct acm_msg *msg) ++static int acm_svr_resolve(struct acm_client *client, struct acm_resolve_msg *msg) + { +- if (msg->resolve_data[0].type == ACM_EP_INFO_PATH) { +- if (msg->resolve_data[0].flags & ACM_FLAGS_QUERY_SA) { ++ if (msg->data[0].type == ACM_EP_INFO_PATH) { ++ if (msg->data[0].flags & ACM_FLAGS_QUERY_SA) { + return acm_svr_query_path(client, msg); + } else { + return acm_svr_resolve_path(client, msg); +@@ -2235,7 +2243,7 @@ static int acm_svr_resolve(struct acm_client *client, struct acm_msg *msg) + } + } + +-static int acm_svr_perf_query(struct acm_client *client, struct acm_msg *msg) ++static int acm_svr_perf_query(struct acm_client *client, struct acm_perf_msg *msg) + { + int ret, i; + +@@ -2248,7 +2256,7 @@ static int acm_svr_perf_query(struct acm_client *client, struct acm_msg *msg) + msg->hdr.length = ACM_MSG_HDR_LENGTH + (ACM_MAX_COUNTER * sizeof(uint64_t)); + + for (i = 0; i < ACM_MAX_COUNTER; i++) +- msg->perf_data[i] = (uint64_t) atomic_get(&counter[i]); ++ msg->data[i] = (uint64_t) atomic_get(&counter[i]); + + ret = send(client->sock, (char *) msg, msg->hdr.length, 0); + if (ret != msg->hdr.length) +@@ -2280,10 +2288,10 @@ static void acm_svr_receive(struct acm_client *client) + switch (msg.hdr.opcode & ACM_OP_MASK) { + case ACM_OP_RESOLVE: + atomic_inc(&counter[ACM_CNTR_RESOLVE]); +- ret = acm_svr_resolve(client, &msg); ++ ret = acm_svr_resolve(client, (struct acm_resolve_msg *) &msg); + break; + case ACM_OP_PERF_QUERY: +- ret = acm_svr_perf_query(client, &msg); ++ ret = acm_svr_perf_query(client, (struct acm_perf_msg *) &msg); + break; + default: + acm_log(0, "ERROR - unknown opcode 0x%x\n", msg.hdr.opcode); -- 2.41.0