Merge tag 'for-linus' of git://github.com/dledford/linux

+4 -2

MAINTAINERS

··· 5042 5042 F: drivers/video/fbdev/imsttfb.c 5043 5043 5044 5044 INFINIBAND SUBSYSTEM 5045 - M: Roland Dreier <roland@kernel.org> 5045 + M: Doug Ledford <dledford@redhat.com> 5046 5046 M: Sean Hefty <sean.hefty@intel.com> 5047 5047 M: Hal Rosenstock <hal.rosenstock@gmail.com> 5048 5048 L: linux-rdma@vger.kernel.org 5049 5049 W: http://www.openfabrics.org/ 5050 5050 Q: http://patchwork.kernel.org/project/linux-rdma/list/ 5051 - T: git git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband.git 5051 + T: git git://github.com/dledford/linux.git 5052 5052 S: Supported 5053 5053 F: Documentation/infiniband/ 5054 5054 F: drivers/infiniband/ 5055 5055 F: include/uapi/linux/if_infiniband.h 5056 + F: include/uapi/rdma/ 5057 + F: include/rdma/ 5056 5058 5057 5059 INOTIFY 5058 5060 M: John McCutchan <john@johnmccutchan.com>

+3 -10

drivers/infiniband/core/addr.c

··· 472 472 } sgid_addr, dgid_addr; 473 473 474 474 475 - ret = rdma_gid2ip(&sgid_addr._sockaddr, sgid); 476 - if (ret) 477 - return ret; 478 - 479 - ret = rdma_gid2ip(&dgid_addr._sockaddr, dgid); 480 - if (ret) 481 - return ret; 475 + rdma_gid2ip(&sgid_addr._sockaddr, sgid); 476 + rdma_gid2ip(&dgid_addr._sockaddr, dgid); 482 477 483 478 memset(&dev_addr, 0, sizeof(dev_addr)); 484 479 ··· 507 512 struct sockaddr_in6 _sockaddr_in6; 508 513 } gid_addr; 509 514 510 - ret = rdma_gid2ip(&gid_addr._sockaddr, sgid); 515 + rdma_gid2ip(&gid_addr._sockaddr, sgid); 511 516 512 - if (ret) 513 - return ret; 514 517 memset(&dev_addr, 0, sizeof(dev_addr)); 515 518 ret = rdma_translate_ip(&gid_addr._sockaddr, &dev_addr, vlan_id); 516 519 if (ret)

+11 -12

drivers/infiniband/core/cm.c

··· 437 437 return cm_id_priv; 438 438 } 439 439 440 - static void cm_mask_copy(u8 *dst, u8 *src, u8 *mask) 440 + static void cm_mask_copy(u32 *dst, const u32 *src, const u32 *mask) 441 441 { 442 442 int i; 443 443 444 - for (i = 0; i < IB_CM_COMPARE_SIZE / sizeof(unsigned long); i++) 445 - ((unsigned long *) dst)[i] = ((unsigned long *) src)[i] & 446 - ((unsigned long *) mask)[i]; 444 + for (i = 0; i < IB_CM_COMPARE_SIZE; i++) 445 + dst[i] = src[i] & mask[i]; 447 446 } 448 447 449 448 static int cm_compare_data(struct ib_cm_compare_data *src_data, 450 449 struct ib_cm_compare_data *dst_data) 451 450 { 452 - u8 src[IB_CM_COMPARE_SIZE]; 453 - u8 dst[IB_CM_COMPARE_SIZE]; 451 + u32 src[IB_CM_COMPARE_SIZE]; 452 + u32 dst[IB_CM_COMPARE_SIZE]; 454 453 455 454 if (!src_data || !dst_data) 456 455 return 0; 457 456 458 457 cm_mask_copy(src, src_data->data, dst_data->mask); 459 458 cm_mask_copy(dst, dst_data->data, src_data->mask); 460 - return memcmp(src, dst, IB_CM_COMPARE_SIZE); 459 + return memcmp(src, dst, sizeof(src)); 461 460 } 462 461 463 - static int cm_compare_private_data(u8 *private_data, 462 + static int cm_compare_private_data(u32 *private_data, 464 463 struct ib_cm_compare_data *dst_data) 465 464 { 466 - u8 src[IB_CM_COMPARE_SIZE]; 465 + u32 src[IB_CM_COMPARE_SIZE]; 467 466 468 467 if (!dst_data) 469 468 return 0; 470 469 471 470 cm_mask_copy(src, private_data, dst_data->mask); 472 - return memcmp(src, dst_data->data, IB_CM_COMPARE_SIZE); 471 + return memcmp(src, dst_data->data, sizeof(src)); 473 472 } 474 473 475 474 /* ··· 537 538 538 539 static struct cm_id_private * cm_find_listen(struct ib_device *device, 539 540 __be64 service_id, 540 - u8 *private_data) 541 + u32 *private_data) 541 542 { 542 543 struct rb_node *node = cm.listen_service_table.rb_node; 543 544 struct cm_id_private *cm_id_priv; ··· 952 953 cm_mask_copy(cm_id_priv->compare_data->data, 953 954 compare_data->data, compare_data->mask); 954 955 memcpy(cm_id_priv->compare_data->mask, compare_data->mask, 955 - IB_CM_COMPARE_SIZE); 956 + sizeof(compare_data->mask)); 956 957 } 957 958 958 959 cm_id->state = IB_CM_LISTEN;

+2 -2

drivers/infiniband/core/cm_msgs.h

··· 103 103 /* local ACK timeout:5, rsvd:3 */ 104 104 u8 alt_offset139; 105 105 106 - u8 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE]; 106 + u32 private_data[IB_CM_REQ_PRIVATE_DATA_SIZE / sizeof(u32)]; 107 107 108 108 } __attribute__ ((packed)); 109 109 ··· 801 801 __be16 rsvd; 802 802 __be64 service_id; 803 803 804 - u8 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE]; 804 + u32 private_data[IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE / sizeof(u32)]; 805 805 } __attribute__ ((packed)); 806 806 807 807 struct cm_sidr_rep_msg {

+17 -10

drivers/infiniband/core/cma.c

··· 859 859 memcpy(&ib->sib_addr, &path->dgid, 16); 860 860 } 861 861 862 + static __be16 ss_get_port(const struct sockaddr_storage *ss) 863 + { 864 + if (ss->ss_family == AF_INET) 865 + return ((struct sockaddr_in *)ss)->sin_port; 866 + else if (ss->ss_family == AF_INET6) 867 + return ((struct sockaddr_in6 *)ss)->sin6_port; 868 + BUG(); 869 + } 870 + 862 871 static void cma_save_ip4_info(struct rdma_cm_id *id, struct rdma_cm_id *listen_id, 863 872 struct cma_hdr *hdr) 864 873 { 865 - struct sockaddr_in *listen4, *ip4; 874 + struct sockaddr_in *ip4; 866 875 867 - listen4 = (struct sockaddr_in *) &listen_id->route.addr.src_addr; 868 876 ip4 = (struct sockaddr_in *) &id->route.addr.src_addr; 869 - ip4->sin_family = listen4->sin_family; 877 + ip4->sin_family = AF_INET; 870 878 ip4->sin_addr.s_addr = hdr->dst_addr.ip4.addr; 871 - ip4->sin_port = listen4->sin_port; 879 + ip4->sin_port = ss_get_port(&listen_id->route.addr.src_addr); 872 880 873 881 ip4 = (struct sockaddr_in *) &id->route.addr.dst_addr; 874 - ip4->sin_family = listen4->sin_family; 882 + ip4->sin_family = AF_INET; 875 883 ip4->sin_addr.s_addr = hdr->src_addr.ip4.addr; 876 884 ip4->sin_port = hdr->port; 877 885 } ··· 887 879 static void cma_save_ip6_info(struct rdma_cm_id *id, struct rdma_cm_id *listen_id, 888 880 struct cma_hdr *hdr) 889 881 { 890 - struct sockaddr_in6 *listen6, *ip6; 882 + struct sockaddr_in6 *ip6; 891 883 892 - listen6 = (struct sockaddr_in6 *) &listen_id->route.addr.src_addr; 893 884 ip6 = (struct sockaddr_in6 *) &id->route.addr.src_addr; 894 - ip6->sin6_family = listen6->sin6_family; 885 + ip6->sin6_family = AF_INET6; 895 886 ip6->sin6_addr = hdr->dst_addr.ip6; 896 - ip6->sin6_port = listen6->sin6_port; 887 + ip6->sin6_port = ss_get_port(&listen_id->route.addr.src_addr); 897 888 898 889 ip6 = (struct sockaddr_in6 *) &id->route.addr.dst_addr; 899 - ip6->sin6_family = listen6->sin6_family; 890 + ip6->sin6_family = AF_INET6; 900 891 ip6->sin6_addr = hdr->src_addr.ip6; 901 892 ip6->sin6_port = hdr->port; 902 893 }

+72 -1

drivers/infiniband/core/iwpm_msg.c

··· 468 468 } 469 469 EXPORT_SYMBOL(iwpm_add_mapping_cb); 470 470 471 - /* netlink attribute policy for the response to add and query mapping request */ 471 + /* netlink attribute policy for the response to add and query mapping request 472 + * and response with remote address info */ 472 473 static const struct nla_policy resp_query_policy[IWPM_NLA_RQUERY_MAPPING_MAX] = { 473 474 [IWPM_NLA_QUERY_MAPPING_SEQ] = { .type = NLA_U32 }, 474 475 [IWPM_NLA_QUERY_LOCAL_ADDR] = { .len = sizeof(struct sockaddr_storage) }, ··· 559 558 return 0; 560 559 } 561 560 EXPORT_SYMBOL(iwpm_add_and_query_mapping_cb); 561 + 562 + /* 563 + * iwpm_remote_info_cb - Process a port mapper message, containing 564 + * the remote connecting peer address info 565 + */ 566 + int iwpm_remote_info_cb(struct sk_buff *skb, struct netlink_callback *cb) 567 + { 568 + struct nlattr *nltb[IWPM_NLA_RQUERY_MAPPING_MAX]; 569 + struct sockaddr_storage *local_sockaddr, *remote_sockaddr; 570 + struct sockaddr_storage *mapped_loc_sockaddr, *mapped_rem_sockaddr; 571 + struct iwpm_remote_info *rem_info; 572 + const char *msg_type; 573 + u8 nl_client; 574 + int ret = -EINVAL; 575 + 576 + msg_type = "Remote Mapping info"; 577 + if (iwpm_parse_nlmsg(cb, IWPM_NLA_RQUERY_MAPPING_MAX, 578 + resp_query_policy, nltb, msg_type)) 579 + return ret; 580 + 581 + nl_client = RDMA_NL_GET_CLIENT(cb->nlh->nlmsg_type); 582 + if (!iwpm_valid_client(nl_client)) { 583 + pr_info("%s: Invalid port mapper client = %d\n", 584 + __func__, nl_client); 585 + return ret; 586 + } 587 + atomic_set(&echo_nlmsg_seq, cb->nlh->nlmsg_seq); 588 + 589 + local_sockaddr = (struct sockaddr_storage *) 590 + nla_data(nltb[IWPM_NLA_QUERY_LOCAL_ADDR]); 591 + remote_sockaddr = (struct sockaddr_storage *) 592 + nla_data(nltb[IWPM_NLA_QUERY_REMOTE_ADDR]); 593 + mapped_loc_sockaddr = (struct sockaddr_storage *) 594 + nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_LOC_ADDR]); 595 + mapped_rem_sockaddr = (struct sockaddr_storage *) 596 + nla_data(nltb[IWPM_NLA_RQUERY_MAPPED_REM_ADDR]); 597 + 598 + if (mapped_loc_sockaddr->ss_family != local_sockaddr->ss_family || 599 + mapped_rem_sockaddr->ss_family != remote_sockaddr->ss_family) { 600 + pr_info("%s: Sockaddr family doesn't match the requested one\n", 601 + __func__); 602 + return ret; 603 + } 604 + rem_info = kzalloc(sizeof(struct iwpm_remote_info), GFP_ATOMIC); 605 + if (!rem_info) { 606 + pr_err("%s: Unable to allocate a remote info\n", __func__); 607 + ret = -ENOMEM; 608 + return ret; 609 + } 610 + memcpy(&rem_info->mapped_loc_sockaddr, mapped_loc_sockaddr, 611 + sizeof(struct sockaddr_storage)); 612 + memcpy(&rem_info->remote_sockaddr, remote_sockaddr, 613 + sizeof(struct sockaddr_storage)); 614 + memcpy(&rem_info->mapped_rem_sockaddr, mapped_rem_sockaddr, 615 + sizeof(struct sockaddr_storage)); 616 + rem_info->nl_client = nl_client; 617 + 618 + iwpm_add_remote_info(rem_info); 619 + 620 + iwpm_print_sockaddr(local_sockaddr, 621 + "remote_info: Local sockaddr:"); 622 + iwpm_print_sockaddr(mapped_loc_sockaddr, 623 + "remote_info: Mapped local sockaddr:"); 624 + iwpm_print_sockaddr(remote_sockaddr, 625 + "remote_info: Remote sockaddr:"); 626 + iwpm_print_sockaddr(mapped_rem_sockaddr, 627 + "remote_info: Mapped remote sockaddr:"); 628 + return ret; 629 + } 630 + EXPORT_SYMBOL(iwpm_remote_info_cb); 562 631 563 632 /* netlink attribute policy for the received request for mapping info */ 564 633 static const struct nla_policy resp_mapinfo_policy[IWPM_NLA_MAPINFO_REQ_MAX] = {

+175 -33

drivers/infiniband/core/iwpm_util.c

··· 33 33 34 34 #include "iwpm_util.h" 35 35 36 - #define IWPM_HASH_BUCKET_SIZE 512 37 - #define IWPM_HASH_BUCKET_MASK (IWPM_HASH_BUCKET_SIZE - 1) 36 + #define IWPM_MAPINFO_HASH_SIZE 512 37 + #define IWPM_MAPINFO_HASH_MASK (IWPM_MAPINFO_HASH_SIZE - 1) 38 + #define IWPM_REMINFO_HASH_SIZE 64 39 + #define IWPM_REMINFO_HASH_MASK (IWPM_REMINFO_HASH_SIZE - 1) 38 40 39 41 static LIST_HEAD(iwpm_nlmsg_req_list); 40 42 static DEFINE_SPINLOCK(iwpm_nlmsg_req_lock); ··· 44 42 static struct hlist_head *iwpm_hash_bucket; 45 43 static DEFINE_SPINLOCK(iwpm_mapinfo_lock); 46 44 45 + static struct hlist_head *iwpm_reminfo_bucket; 46 + static DEFINE_SPINLOCK(iwpm_reminfo_lock); 47 + 47 48 static DEFINE_MUTEX(iwpm_admin_lock); 48 49 static struct iwpm_admin_data iwpm_admin; 49 50 50 51 int iwpm_init(u8 nl_client) 51 52 { 53 + int ret = 0; 52 54 if (iwpm_valid_client(nl_client)) 53 55 return -EINVAL; 54 56 mutex_lock(&iwpm_admin_lock); 55 57 if (atomic_read(&iwpm_admin.refcount) == 0) { 56 - iwpm_hash_bucket = kzalloc(IWPM_HASH_BUCKET_SIZE * 58 + iwpm_hash_bucket = kzalloc(IWPM_MAPINFO_HASH_SIZE * 57 59 sizeof(struct hlist_head), GFP_KERNEL); 58 60 if (!iwpm_hash_bucket) { 59 - mutex_unlock(&iwpm_admin_lock); 61 + ret = -ENOMEM; 60 62 pr_err("%s Unable to create mapinfo hash table\n", __func__); 61 - return -ENOMEM; 63 + goto init_exit; 64 + } 65 + iwpm_reminfo_bucket = kzalloc(IWPM_REMINFO_HASH_SIZE * 66 + sizeof(struct hlist_head), GFP_KERNEL); 67 + if (!iwpm_reminfo_bucket) { 68 + kfree(iwpm_hash_bucket); 69 + ret = -ENOMEM; 70 + pr_err("%s Unable to create reminfo hash table\n", __func__); 71 + goto init_exit; 62 72 } 63 73 } 64 74 atomic_inc(&iwpm_admin.refcount); 75 + init_exit: 65 76 mutex_unlock(&iwpm_admin_lock); 66 - iwpm_set_valid(nl_client, 1); 67 - return 0; 77 + if (!ret) { 78 + iwpm_set_valid(nl_client, 1); 79 + pr_debug("%s: Mapinfo and reminfo tables are created\n", 80 + __func__); 81 + } 82 + return ret; 68 83 } 69 84 EXPORT_SYMBOL(iwpm_init); 70 85 71 86 static void free_hash_bucket(void); 87 + static void free_reminfo_bucket(void); 72 88 73 89 int iwpm_exit(u8 nl_client) 74 90 { ··· 101 81 } 102 82 if (atomic_dec_and_test(&iwpm_admin.refcount)) { 103 83 free_hash_bucket(); 104 - pr_debug("%s: Mapinfo hash table is destroyed\n", __func__); 84 + free_reminfo_bucket(); 85 + pr_debug("%s: Resources are destroyed\n", __func__); 105 86 } 106 87 mutex_unlock(&iwpm_admin_lock); 107 88 iwpm_set_valid(nl_client, 0); ··· 110 89 } 111 90 EXPORT_SYMBOL(iwpm_exit); 112 91 113 - static struct hlist_head *get_hash_bucket_head(struct sockaddr_storage *, 92 + static struct hlist_head *get_mapinfo_hash_bucket(struct sockaddr_storage *, 114 93 struct sockaddr_storage *); 115 94 116 95 int iwpm_create_mapinfo(struct sockaddr_storage *local_sockaddr, ··· 120 99 struct hlist_head *hash_bucket_head; 121 100 struct iwpm_mapping_info *map_info; 122 101 unsigned long flags; 102 + int ret = -EINVAL; 123 103 124 104 if (!iwpm_valid_client(nl_client)) 125 - return -EINVAL; 105 + return ret; 126 106 map_info = kzalloc(sizeof(struct iwpm_mapping_info), GFP_KERNEL); 127 107 if (!map_info) { 128 108 pr_err("%s: Unable to allocate a mapping info\n", __func__); ··· 137 115 138 116 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 139 117 if (iwpm_hash_bucket) { 140 - hash_bucket_head = get_hash_bucket_head( 118 + hash_bucket_head = get_mapinfo_hash_bucket( 141 119 &map_info->local_sockaddr, 142 120 &map_info->mapped_sockaddr); 143 - hlist_add_head(&map_info->hlist_node, hash_bucket_head); 121 + if (hash_bucket_head) { 122 + hlist_add_head(&map_info->hlist_node, hash_bucket_head); 123 + ret = 0; 124 + } 144 125 } 145 126 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 146 - return 0; 127 + return ret; 147 128 } 148 129 EXPORT_SYMBOL(iwpm_create_mapinfo); 149 130 ··· 161 136 162 137 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 163 138 if (iwpm_hash_bucket) { 164 - hash_bucket_head = get_hash_bucket_head( 139 + hash_bucket_head = get_mapinfo_hash_bucket( 165 140 local_sockaddr, 166 141 mapped_local_addr); 142 + if (!hash_bucket_head) 143 + goto remove_mapinfo_exit; 144 + 167 145 hlist_for_each_entry_safe(map_info, tmp_hlist_node, 168 146 hash_bucket_head, hlist_node) { 169 147 ··· 180 152 } 181 153 } 182 154 } 155 + remove_mapinfo_exit: 183 156 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 184 157 return ret; 185 158 } ··· 195 166 196 167 /* remove all the mapinfo data from the list */ 197 168 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 198 - for (i = 0; i < IWPM_HASH_BUCKET_SIZE; i++) { 169 + for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 199 170 hlist_for_each_entry_safe(map_info, tmp_hlist_node, 200 171 &iwpm_hash_bucket[i], hlist_node) { 201 172 ··· 208 179 iwpm_hash_bucket = NULL; 209 180 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 210 181 } 182 + 183 + static void free_reminfo_bucket(void) 184 + { 185 + struct hlist_node *tmp_hlist_node; 186 + struct iwpm_remote_info *rem_info; 187 + unsigned long flags; 188 + int i; 189 + 190 + /* remove all the remote info from the list */ 191 + spin_lock_irqsave(&iwpm_reminfo_lock, flags); 192 + for (i = 0; i < IWPM_REMINFO_HASH_SIZE; i++) { 193 + hlist_for_each_entry_safe(rem_info, tmp_hlist_node, 194 + &iwpm_reminfo_bucket[i], hlist_node) { 195 + 196 + hlist_del_init(&rem_info->hlist_node); 197 + kfree(rem_info); 198 + } 199 + } 200 + /* free the hash list */ 201 + kfree(iwpm_reminfo_bucket); 202 + iwpm_reminfo_bucket = NULL; 203 + spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 204 + } 205 + 206 + static struct hlist_head *get_reminfo_hash_bucket(struct sockaddr_storage *, 207 + struct sockaddr_storage *); 208 + 209 + void iwpm_add_remote_info(struct iwpm_remote_info *rem_info) 210 + { 211 + struct hlist_head *hash_bucket_head; 212 + unsigned long flags; 213 + 214 + spin_lock_irqsave(&iwpm_reminfo_lock, flags); 215 + if (iwpm_reminfo_bucket) { 216 + hash_bucket_head = get_reminfo_hash_bucket( 217 + &rem_info->mapped_loc_sockaddr, 218 + &rem_info->mapped_rem_sockaddr); 219 + if (hash_bucket_head) 220 + hlist_add_head(&rem_info->hlist_node, hash_bucket_head); 221 + } 222 + spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 223 + } 224 + 225 + int iwpm_get_remote_info(struct sockaddr_storage *mapped_loc_addr, 226 + struct sockaddr_storage *mapped_rem_addr, 227 + struct sockaddr_storage *remote_addr, 228 + u8 nl_client) 229 + { 230 + struct hlist_node *tmp_hlist_node; 231 + struct hlist_head *hash_bucket_head; 232 + struct iwpm_remote_info *rem_info = NULL; 233 + unsigned long flags; 234 + int ret = -EINVAL; 235 + 236 + if (!iwpm_valid_client(nl_client)) { 237 + pr_info("%s: Invalid client = %d\n", __func__, nl_client); 238 + return ret; 239 + } 240 + spin_lock_irqsave(&iwpm_reminfo_lock, flags); 241 + if (iwpm_reminfo_bucket) { 242 + hash_bucket_head = get_reminfo_hash_bucket( 243 + mapped_loc_addr, 244 + mapped_rem_addr); 245 + if (!hash_bucket_head) 246 + goto get_remote_info_exit; 247 + hlist_for_each_entry_safe(rem_info, tmp_hlist_node, 248 + hash_bucket_head, hlist_node) { 249 + 250 + if (!iwpm_compare_sockaddr(&rem_info->mapped_loc_sockaddr, 251 + mapped_loc_addr) && 252 + !iwpm_compare_sockaddr(&rem_info->mapped_rem_sockaddr, 253 + mapped_rem_addr)) { 254 + 255 + memcpy(remote_addr, &rem_info->remote_sockaddr, 256 + sizeof(struct sockaddr_storage)); 257 + iwpm_print_sockaddr(remote_addr, 258 + "get_remote_info: Remote sockaddr:"); 259 + 260 + hlist_del_init(&rem_info->hlist_node); 261 + kfree(rem_info); 262 + ret = 0; 263 + break; 264 + } 265 + } 266 + } 267 + get_remote_info_exit: 268 + spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 269 + return ret; 270 + } 271 + EXPORT_SYMBOL(iwpm_get_remote_info); 211 272 212 273 struct iwpm_nlmsg_request *iwpm_get_nlmsg_request(__u32 nlmsg_seq, 213 274 u8 nl_client, gfp_t gfp) ··· 528 409 return hash; 529 410 } 530 411 531 - static struct hlist_head *get_hash_bucket_head(struct sockaddr_storage 532 - *local_sockaddr, 533 - struct sockaddr_storage 534 - *mapped_sockaddr) 412 + static int get_hash_bucket(struct sockaddr_storage *a_sockaddr, 413 + struct sockaddr_storage *b_sockaddr, u32 *hash) 535 414 { 536 - u32 local_hash, mapped_hash, hash; 415 + u32 a_hash, b_hash; 537 416 538 - if (local_sockaddr->ss_family == AF_INET) { 539 - local_hash = iwpm_ipv4_jhash((struct sockaddr_in *) local_sockaddr); 540 - mapped_hash = iwpm_ipv4_jhash((struct sockaddr_in *) mapped_sockaddr); 417 + if (a_sockaddr->ss_family == AF_INET) { 418 + a_hash = iwpm_ipv4_jhash((struct sockaddr_in *) a_sockaddr); 419 + b_hash = iwpm_ipv4_jhash((struct sockaddr_in *) b_sockaddr); 541 420 542 - } else if (local_sockaddr->ss_family == AF_INET6) { 543 - local_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) local_sockaddr); 544 - mapped_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) mapped_sockaddr); 421 + } else if (a_sockaddr->ss_family == AF_INET6) { 422 + a_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) a_sockaddr); 423 + b_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) b_sockaddr); 545 424 } else { 546 425 pr_err("%s: Invalid sockaddr family\n", __func__); 547 - return NULL; 426 + return -EINVAL; 548 427 } 549 428 550 - if (local_hash == mapped_hash) /* if port mapper isn't available */ 551 - hash = local_hash; 429 + if (a_hash == b_hash) /* if port mapper isn't available */ 430 + *hash = a_hash; 552 431 else 553 - hash = jhash_2words(local_hash, mapped_hash, 0); 432 + *hash = jhash_2words(a_hash, b_hash, 0); 433 + return 0; 434 + } 554 435 555 - return &iwpm_hash_bucket[hash & IWPM_HASH_BUCKET_MASK]; 436 + static struct hlist_head *get_mapinfo_hash_bucket(struct sockaddr_storage 437 + *local_sockaddr, struct sockaddr_storage 438 + *mapped_sockaddr) 439 + { 440 + u32 hash; 441 + int ret; 442 + 443 + ret = get_hash_bucket(local_sockaddr, mapped_sockaddr, &hash); 444 + if (ret) 445 + return NULL; 446 + return &iwpm_hash_bucket[hash & IWPM_MAPINFO_HASH_MASK]; 447 + } 448 + 449 + static struct hlist_head *get_reminfo_hash_bucket(struct sockaddr_storage 450 + *mapped_loc_sockaddr, struct sockaddr_storage 451 + *mapped_rem_sockaddr) 452 + { 453 + u32 hash; 454 + int ret; 455 + 456 + ret = get_hash_bucket(mapped_loc_sockaddr, mapped_rem_sockaddr, &hash); 457 + if (ret) 458 + return NULL; 459 + return &iwpm_reminfo_bucket[hash & IWPM_REMINFO_HASH_MASK]; 556 460 } 557 461 558 462 static int send_mapinfo_num(u32 mapping_num, u8 nl_client, int iwpm_pid) ··· 654 512 } 655 513 skb_num++; 656 514 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 657 - for (i = 0; i < IWPM_HASH_BUCKET_SIZE; i++) { 515 + for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 658 516 hlist_for_each_entry(map_info, &iwpm_hash_bucket[i], 659 517 hlist_node) { 660 518 if (map_info->nl_client != nl_client) ··· 737 595 738 596 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 739 597 if (iwpm_hash_bucket) { 740 - for (i = 0; i < IWPM_HASH_BUCKET_SIZE; i++) { 598 + for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 741 599 if (!hlist_empty(&iwpm_hash_bucket[i])) { 742 600 full_bucket = 1; 743 601 break;

+15

drivers/infiniband/core/iwpm_util.h

··· 76 76 u8 nl_client; 77 77 }; 78 78 79 + struct iwpm_remote_info { 80 + struct hlist_node hlist_node; 81 + struct sockaddr_storage remote_sockaddr; 82 + struct sockaddr_storage mapped_loc_sockaddr; 83 + struct sockaddr_storage mapped_rem_sockaddr; 84 + u8 nl_client; 85 + }; 86 + 79 87 struct iwpm_admin_data { 80 88 atomic_t refcount; 81 89 atomic_t nlmsg_seq; ··· 134 126 * Returns the sequence number for the netlink message. 135 127 */ 136 128 int iwpm_get_nlmsg_seq(void); 129 + 130 + /** 131 + * iwpm_add_reminfo - Add remote address info of the connecting peer 132 + * to the remote info hash table 133 + * @reminfo: The remote info to be added 134 + */ 135 + void iwpm_add_remote_info(struct iwpm_remote_info *reminfo); 137 136 138 137 /** 139 138 * iwpm_valid_client - Check if the port mapper client is valid

+7 -7

drivers/infiniband/core/umem_odp.c

··· 446 446 int remove_existing_mapping = 0; 447 447 int ret = 0; 448 448 449 - mutex_lock(&umem->odp_data->umem_mutex); 450 449 /* 451 450 * Note: we avoid writing if seq is different from the initial seq, to 452 451 * handle case of a racing notifier. This check also allows us to bail ··· 478 479 } 479 480 480 481 out: 481 - mutex_unlock(&umem->odp_data->umem_mutex); 482 - 483 482 /* On Demand Paging - avoid pinning the page */ 484 483 if (umem->context->invalidate_range || !stored_page) 485 484 put_page(page); ··· 583 586 584 587 bcnt -= min_t(size_t, npages << PAGE_SHIFT, bcnt); 585 588 user_virt += npages << PAGE_SHIFT; 589 + mutex_lock(&umem->odp_data->umem_mutex); 586 590 for (j = 0; j < npages; ++j) { 587 591 ret = ib_umem_odp_map_dma_single_page( 588 592 umem, k, base_virt_addr, local_page_list[j], ··· 592 594 break; 593 595 k++; 594 596 } 597 + mutex_unlock(&umem->odp_data->umem_mutex); 595 598 596 599 if (ret < 0) { 597 600 /* Release left over pages when handling errors. */ ··· 632 633 * faults from completion. We might be racing with other 633 634 * invalidations, so we must make sure we free each page only 634 635 * once. */ 636 + mutex_lock(&umem->odp_data->umem_mutex); 635 637 for (addr = virt; addr < bound; addr += (u64)umem->page_size) { 636 638 idx = (addr - ib_umem_start(umem)) / PAGE_SIZE; 637 - mutex_lock(&umem->odp_data->umem_mutex); 638 639 if (umem->odp_data->page_list[idx]) { 639 640 struct page *page = umem->odp_data->page_list[idx]; 640 - struct page *head_page = compound_head(page); 641 641 dma_addr_t dma = umem->odp_data->dma_list[idx]; 642 642 dma_addr_t dma_addr = dma & ODP_DMA_ADDR_MASK; 643 643 ··· 644 646 645 647 ib_dma_unmap_page(dev, dma_addr, PAGE_SIZE, 646 648 DMA_BIDIRECTIONAL); 647 - if (dma & ODP_WRITE_ALLOWED_BIT) 649 + if (dma & ODP_WRITE_ALLOWED_BIT) { 650 + struct page *head_page = compound_head(page); 648 651 /* 649 652 * set_page_dirty prefers being called with 650 653 * the page lock. However, MMU notifiers are ··· 656 657 * be removed. 657 658 */ 658 659 set_page_dirty(head_page); 660 + } 659 661 /* on demand pinning support */ 660 662 if (!umem->context->invalidate_range) 661 663 put_page(page); 662 664 umem->odp_data->page_list[idx] = NULL; 663 665 umem->odp_data->dma_list[idx] = 0; 664 666 } 665 - mutex_unlock(&umem->odp_data->umem_mutex); 666 667 } 668 + mutex_unlock(&umem->odp_data->umem_mutex); 667 669 } 668 670 EXPORT_SYMBOL(ib_umem_odp_unmap_dma_pages);

+71 -16

drivers/infiniband/hw/cxgb4/cm.c

··· 583 583 sizeof(ep->com.mapped_remote_addr)); 584 584 } 585 585 586 + static int get_remote_addr(struct c4iw_ep *ep) 587 + { 588 + int ret; 589 + 590 + print_addr(&ep->com, __func__, "get_remote_addr"); 591 + 592 + ret = iwpm_get_remote_info(&ep->com.mapped_local_addr, 593 + &ep->com.mapped_remote_addr, 594 + &ep->com.remote_addr, RDMA_NL_C4IW); 595 + if (ret) 596 + pr_info(MOD "Unable to find remote peer addr info - err %d\n", 597 + ret); 598 + 599 + return ret; 600 + } 601 + 586 602 static void best_mtu(const unsigned short *mtus, unsigned short mtu, 587 603 unsigned int *idx, int use_ts, int ipv6) 588 604 { ··· 691 675 if (is_t5(ep->com.dev->rdev.lldi.adapter_type)) { 692 676 opt2 |= T5_OPT_2_VALID_F; 693 677 opt2 |= CONG_CNTRL_V(CONG_ALG_TAHOE); 694 - opt2 |= CONG_CNTRL_VALID; /* OPT_2_ISS for T5 */ 678 + opt2 |= T5_ISS_F; 695 679 } 696 680 t4_set_arp_err_handler(skb, ep, act_open_req_arp_failure); 697 681 ··· 2058 2042 status, status2errno(status)); 2059 2043 2060 2044 if (is_neg_adv(status)) { 2061 - dev_warn(&dev->rdev.lldi.pdev->dev, 2062 - "Connection problems for atid %u status %u (%s)\n", 2063 - atid, status, neg_adv_str(status)); 2045 + PDBG("%s Connection problems for atid %u status %u (%s)\n", 2046 + __func__, atid, status, neg_adv_str(status)); 2047 + ep->stats.connect_neg_adv++; 2048 + mutex_lock(&dev->rdev.stats.lock); 2049 + dev->rdev.stats.neg_adv++; 2050 + mutex_unlock(&dev->rdev.stats.lock); 2064 2051 return 0; 2065 2052 } 2066 2053 ··· 2233 2214 u32 isn = (prandom_u32() & ~7UL) - 1; 2234 2215 opt2 |= T5_OPT_2_VALID_F; 2235 2216 opt2 |= CONG_CNTRL_V(CONG_ALG_TAHOE); 2236 - opt2 |= CONG_CNTRL_VALID; /* OPT_2_ISS for T5 */ 2217 + opt2 |= T5_ISS_F; 2237 2218 rpl5 = (void *)rpl; 2238 2219 memset(&rpl5->iss, 0, roundup(sizeof(*rpl5)-sizeof(*rpl), 16)); 2239 2220 if (peer2peer) ··· 2371 2352 state_set(&child_ep->com, CONNECTING); 2372 2353 child_ep->com.dev = dev; 2373 2354 child_ep->com.cm_id = NULL; 2355 + 2356 + /* 2357 + * The mapped_local and mapped_remote addresses get setup with 2358 + * the actual 4-tuple. The local address will be based on the 2359 + * actual local address of the connection, but on the port number 2360 + * of the parent listening endpoint. The remote address is 2361 + * setup based on a query to the IWPM since we don't know what it 2362 + * originally was before mapping. If no mapping was done, then 2363 + * mapped_remote == remote, and mapped_local == local. 2364 + */ 2374 2365 if (iptype == 4) { 2375 2366 struct sockaddr_in *sin = (struct sockaddr_in *) 2376 - &child_ep->com.local_addr; 2367 + &child_ep->com.mapped_local_addr; 2368 + 2377 2369 sin->sin_family = PF_INET; 2378 2370 sin->sin_port = local_port; 2379 2371 sin->sin_addr.s_addr = *(__be32 *)local_ip; 2380 - sin = (struct sockaddr_in *)&child_ep->com.remote_addr; 2372 + 2373 + sin = (struct sockaddr_in *)&child_ep->com.local_addr; 2374 + sin->sin_family = PF_INET; 2375 + sin->sin_port = ((struct sockaddr_in *) 2376 + &parent_ep->com.local_addr)->sin_port; 2377 + sin->sin_addr.s_addr = *(__be32 *)local_ip; 2378 + 2379 + sin = (struct sockaddr_in *)&child_ep->com.mapped_remote_addr; 2381 2380 sin->sin_family = PF_INET; 2382 2381 sin->sin_port = peer_port; 2383 2382 sin->sin_addr.s_addr = *(__be32 *)peer_ip; 2384 2383 } else { 2385 2384 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) 2386 - &child_ep->com.local_addr; 2385 + &child_ep->com.mapped_local_addr; 2386 + 2387 2387 sin6->sin6_family = PF_INET6; 2388 2388 sin6->sin6_port = local_port; 2389 2389 memcpy(sin6->sin6_addr.s6_addr, local_ip, 16); 2390 - sin6 = (struct sockaddr_in6 *)&child_ep->com.remote_addr; 2390 + 2391 + sin6 = (struct sockaddr_in6 *)&child_ep->com.local_addr; 2392 + sin6->sin6_family = PF_INET6; 2393 + sin6->sin6_port = ((struct sockaddr_in6 *) 2394 + &parent_ep->com.local_addr)->sin6_port; 2395 + memcpy(sin6->sin6_addr.s6_addr, local_ip, 16); 2396 + 2397 + sin6 = (struct sockaddr_in6 *)&child_ep->com.mapped_remote_addr; 2391 2398 sin6->sin6_family = PF_INET6; 2392 2399 sin6->sin6_port = peer_port; 2393 2400 memcpy(sin6->sin6_addr.s6_addr, peer_ip, 16); 2394 2401 } 2402 + memcpy(&child_ep->com.remote_addr, &child_ep->com.mapped_remote_addr, 2403 + sizeof(child_ep->com.remote_addr)); 2404 + get_remote_addr(child_ep); 2405 + 2395 2406 c4iw_get_ep(&parent_ep->com); 2396 2407 child_ep->parent_ep = parent_ep; 2397 2408 child_ep->tos = PASS_OPEN_TOS_G(ntohl(req->tos_stid)); ··· 2569 2520 2570 2521 ep = lookup_tid(t, tid); 2571 2522 if (is_neg_adv(req->status)) { 2572 - dev_warn(&dev->rdev.lldi.pdev->dev, 2573 - "Negative advice on abort - tid %u status %d (%s)\n", 2574 - ep->hwtid, req->status, neg_adv_str(req->status)); 2523 + PDBG("%s Negative advice on abort- tid %u status %d (%s)\n", 2524 + __func__, ep->hwtid, req->status, 2525 + neg_adv_str(req->status)); 2526 + ep->stats.abort_neg_adv++; 2527 + mutex_lock(&dev->rdev.stats.lock); 2528 + dev->rdev.stats.neg_adv++; 2529 + mutex_unlock(&dev->rdev.stats.lock); 2575 2530 return 0; 2576 2531 } 2577 2532 PDBG("%s ep %p tid %u state %u\n", __func__, ep, ep->hwtid, ··· 3624 3571 * TP will ignore any value > 0 for MSS index. 3625 3572 */ 3626 3573 req->tcb.opt0 = cpu_to_be64(MSS_IDX_V(0xF)); 3627 - req->cookie = (unsigned long)skb; 3574 + req->cookie = (uintptr_t)skb; 3628 3575 3629 3576 set_wr_txq(req_skb, CPL_PRIORITY_CONTROL, port_id); 3630 3577 ret = cxgb4_ofld_send(dev->rdev.lldi.ports[0], req_skb); ··· 3984 3931 return 0; 3985 3932 } 3986 3933 if (is_neg_adv(req->status)) { 3987 - dev_warn(&dev->rdev.lldi.pdev->dev, 3988 - "Negative advice on abort - tid %u status %d (%s)\n", 3989 - ep->hwtid, req->status, neg_adv_str(req->status)); 3934 + PDBG("%s Negative advice on abort- tid %u status %d (%s)\n", 3935 + __func__, ep->hwtid, req->status, 3936 + neg_adv_str(req->status)); 3937 + ep->stats.abort_neg_adv++; 3938 + dev->rdev.stats.neg_adv++; 3990 3939 kfree_skb(skb); 3991 3940 return 0; 3992 3941 }

+14 -8

drivers/infiniband/hw/cxgb4/cq.c

··· 55 55 FW_RI_RES_WR_NRES_V(1) | 56 56 FW_WR_COMPL_F); 57 57 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); 58 - res_wr->cookie = (unsigned long) &wr_wait; 58 + res_wr->cookie = (uintptr_t)&wr_wait; 59 59 res = res_wr->res; 60 60 res->u.cq.restype = FW_RI_RES_TYPE_CQ; 61 61 res->u.cq.op = FW_RI_RES_OP_RESET; ··· 125 125 FW_RI_RES_WR_NRES_V(1) | 126 126 FW_WR_COMPL_F); 127 127 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); 128 - res_wr->cookie = (unsigned long) &wr_wait; 128 + res_wr->cookie = (uintptr_t)&wr_wait; 129 129 res = res_wr->res; 130 130 res->u.cq.restype = FW_RI_RES_TYPE_CQ; 131 131 res->u.cq.op = FW_RI_RES_OP_WRITE; ··· 156 156 goto err4; 157 157 158 158 cq->gen = 1; 159 - cq->gts = rdev->lldi.gts_reg; 160 159 cq->rdev = rdev; 161 160 if (user) { 162 - cq->ugts = (u64)pci_resource_start(rdev->lldi.pdev, 2) + 163 - (cq->cqid << rdev->cqshift); 164 - cq->ugts &= PAGE_MASK; 161 + u32 off = (cq->cqid << rdev->cqshift) & PAGE_MASK; 162 + 163 + cq->ugts = (u64)rdev->bar2_pa + off; 164 + } else if (is_t4(rdev->lldi.adapter_type)) { 165 + cq->gts = rdev->lldi.gts_reg; 166 + cq->qid_mask = -1U; 167 + } else { 168 + u32 off = ((cq->cqid << rdev->cqshift) & PAGE_MASK) + 12; 169 + 170 + cq->gts = rdev->bar2_kva + off; 171 + cq->qid_mask = rdev->qpmask; 165 172 } 166 173 return 0; 167 174 err4: ··· 977 970 } 978 971 PDBG("%s cqid 0x%0x chp %p size %u memsize %zu, dma_addr 0x%0llx\n", 979 972 __func__, chp->cq.cqid, chp, chp->cq.size, 980 - chp->cq.memsize, 981 - (unsigned long long) chp->cq.dma_addr); 973 + chp->cq.memsize, (unsigned long long) chp->cq.dma_addr); 982 974 return &chp->ibcq; 983 975 err5: 984 976 kfree(mm2);

+34 -3

drivers/infiniband/hw/cxgb4/device.c

··· 93 93 [RDMA_NL_IWPM_ADD_MAPPING] = {.dump = iwpm_add_mapping_cb}, 94 94 [RDMA_NL_IWPM_QUERY_MAPPING] = {.dump = iwpm_add_and_query_mapping_cb}, 95 95 [RDMA_NL_IWPM_HANDLE_ERR] = {.dump = iwpm_mapping_error_cb}, 96 + [RDMA_NL_IWPM_REMOTE_INFO] = {.dump = iwpm_remote_info_cb}, 96 97 [RDMA_NL_IWPM_MAPINFO] = {.dump = iwpm_mapping_info_cb}, 97 98 [RDMA_NL_IWPM_MAPINFO_NUM] = {.dump = iwpm_ack_mapping_info_cb} 98 99 }; ··· 152 151 int prev_ts_set = 0; 153 152 int idx, end; 154 153 155 - #define ts2ns(ts) div64_ul((ts) * dev->rdev.lldi.cclk_ps, 1000) 154 + #define ts2ns(ts) div64_u64((ts) * dev->rdev.lldi.cclk_ps, 1000) 156 155 157 156 idx = atomic_read(&dev->rdev.wr_log_idx) & 158 157 (dev->rdev.wr_log_size - 1); ··· 490 489 dev->rdev.stats.act_ofld_conn_fails); 491 490 seq_printf(seq, "PAS_OFLD_CONN_FAILS: %10llu\n", 492 491 dev->rdev.stats.pas_ofld_conn_fails); 492 + seq_printf(seq, "NEG_ADV_RCVD: %10llu\n", dev->rdev.stats.neg_adv); 493 493 seq_printf(seq, "AVAILABLE IRD: %10u\n", dev->avail_ird); 494 494 return 0; 495 495 } ··· 562 560 cc = snprintf(epd->buf + epd->pos, space, 563 561 "ep %p cm_id %p qp %p state %d flags 0x%lx " 564 562 "history 0x%lx hwtid %d atid %d " 563 + "conn_na %u abort_na %u " 565 564 "%pI4:%d/%d <-> %pI4:%d/%d\n", 566 565 ep, ep->com.cm_id, ep->com.qp, 567 566 (int)ep->com.state, ep->com.flags, 568 567 ep->com.history, ep->hwtid, ep->atid, 568 + ep->stats.connect_neg_adv, 569 + ep->stats.abort_neg_adv, 569 570 &lsin->sin_addr, ntohs(lsin->sin_port), 570 571 ntohs(mapped_lsin->sin_port), 571 572 &rsin->sin_addr, ntohs(rsin->sin_port), ··· 586 581 cc = snprintf(epd->buf + epd->pos, space, 587 582 "ep %p cm_id %p qp %p state %d flags 0x%lx " 588 583 "history 0x%lx hwtid %d atid %d " 584 + "conn_na %u abort_na %u " 589 585 "%pI6:%d/%d <-> %pI6:%d/%d\n", 590 586 ep, ep->com.cm_id, ep->com.qp, 591 587 (int)ep->com.state, ep->com.flags, 592 588 ep->com.history, ep->hwtid, ep->atid, 589 + ep->stats.connect_neg_adv, 590 + ep->stats.abort_neg_adv, 593 591 &lsin6->sin6_addr, ntohs(lsin6->sin6_port), 594 592 ntohs(mapped_lsin6->sin6_port), 595 593 &rsin6->sin6_addr, ntohs(rsin6->sin6_port), ··· 773 765 c4iw_init_dev_ucontext(rdev, &rdev->uctx); 774 766 775 767 /* 768 + * This implementation assumes udb_density == ucq_density! Eventually 769 + * we might need to support this but for now fail the open. Also the 770 + * cqid and qpid range must match for now. 771 + */ 772 + if (rdev->lldi.udb_density != rdev->lldi.ucq_density) { 773 + pr_err(MOD "%s: unsupported udb/ucq densities %u/%u\n", 774 + pci_name(rdev->lldi.pdev), rdev->lldi.udb_density, 775 + rdev->lldi.ucq_density); 776 + err = -EINVAL; 777 + goto err1; 778 + } 779 + if (rdev->lldi.vr->qp.start != rdev->lldi.vr->cq.start || 780 + rdev->lldi.vr->qp.size != rdev->lldi.vr->cq.size) { 781 + pr_err(MOD "%s: unsupported qp and cq id ranges " 782 + "qp start %u size %u cq start %u size %u\n", 783 + pci_name(rdev->lldi.pdev), rdev->lldi.vr->qp.start, 784 + rdev->lldi.vr->qp.size, rdev->lldi.vr->cq.size, 785 + rdev->lldi.vr->cq.size); 786 + err = -EINVAL; 787 + goto err1; 788 + } 789 + 790 + /* 776 791 * qpshift is the number of bits to shift the qpid left in order 777 792 * to get the correct address of the doorbell for that qp. 778 793 */ ··· 815 784 rdev->lldi.vr->qp.size, 816 785 rdev->lldi.vr->cq.start, 817 786 rdev->lldi.vr->cq.size); 818 - PDBG("udb len 0x%x udb base %llx db_reg %p gts_reg %p qpshift %lu " 787 + PDBG("udb len 0x%x udb base %p db_reg %p gts_reg %p qpshift %lu " 819 788 "qpmask 0x%x cqshift %lu cqmask 0x%x\n", 820 789 (unsigned)pci_resource_len(rdev->lldi.pdev, 2), 821 - (u64)pci_resource_start(rdev->lldi.pdev, 2), 790 + (void *)pci_resource_start(rdev->lldi.pdev, 2), 822 791 rdev->lldi.db_reg, 823 792 rdev->lldi.gts_reg, 824 793 rdev->qpshift, rdev->qpmask,

+7

drivers/infiniband/hw/cxgb4/iw_cxgb4.h

··· 137 137 u64 tcam_full; 138 138 u64 act_ofld_conn_fails; 139 139 u64 pas_ofld_conn_fails; 140 + u64 neg_adv; 140 141 }; 141 142 142 143 struct c4iw_hw_queue { ··· 815 814 int backlog; 816 815 }; 817 816 817 + struct c4iw_ep_stats { 818 + unsigned connect_neg_adv; 819 + unsigned abort_neg_adv; 820 + }; 821 + 818 822 struct c4iw_ep { 819 823 struct c4iw_ep_common com; 820 824 struct c4iw_ep *parent_ep; ··· 852 846 unsigned int retry_count; 853 847 int snd_win; 854 848 int rcv_win; 849 + struct c4iw_ep_stats stats; 855 850 }; 856 851 857 852 static inline void print_addr(struct c4iw_ep_common *epc, const char *func,

+3 -3

drivers/infiniband/hw/cxgb4/mem.c

··· 144 144 if (i == (num_wqe-1)) { 145 145 req->wr.wr_hi = cpu_to_be32(FW_WR_OP_V(FW_ULPTX_WR) | 146 146 FW_WR_COMPL_F); 147 - req->wr.wr_lo = (__force __be64)(unsigned long) &wr_wait; 147 + req->wr.wr_lo = (__force __be64)&wr_wait; 148 148 } else 149 149 req->wr.wr_hi = cpu_to_be32(FW_WR_OP_V(FW_ULPTX_WR)); 150 150 req->wr.wr_mid = cpu_to_be32( ··· 676 676 mhp->attr.zbva = 0; 677 677 mhp->attr.va_fbo = 0; 678 678 mhp->attr.page_size = 0; 679 - mhp->attr.len = ~0UL; 679 + mhp->attr.len = ~0ULL; 680 680 mhp->attr.pbl_size = 0; 681 681 682 682 ret = write_tpt_entry(&rhp->rdev, 0, &stag, 1, php->pdid, 683 683 FW_RI_STAG_NSMR, mhp->attr.perms, 684 - mhp->attr.mw_bind_enable, 0, 0, ~0UL, 0, 0, 0); 684 + mhp->attr.mw_bind_enable, 0, 0, ~0ULL, 0, 0, 0); 685 685 if (ret) 686 686 goto err1; 687 687

+5 -5

drivers/infiniband/hw/cxgb4/qp.c

··· 275 275 FW_RI_RES_WR_NRES_V(2) | 276 276 FW_WR_COMPL_F); 277 277 res_wr->len16_pkd = cpu_to_be32(DIV_ROUND_UP(wr_len, 16)); 278 - res_wr->cookie = (unsigned long) &wr_wait; 278 + res_wr->cookie = (uintptr_t)&wr_wait; 279 279 res = res_wr->res; 280 280 res->u.sqrq.restype = FW_RI_RES_TYPE_SQ; 281 281 res->u.sqrq.op = FW_RI_RES_OP_WRITE; ··· 1209 1209 wqe->flowid_len16 = cpu_to_be32( 1210 1210 FW_WR_FLOWID_V(ep->hwtid) | 1211 1211 FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*wqe), 16))); 1212 - wqe->cookie = (unsigned long) &ep->com.wr_wait; 1212 + wqe->cookie = (uintptr_t)&ep->com.wr_wait; 1213 1213 1214 1214 wqe->u.fini.type = FW_RI_TYPE_FINI; 1215 1215 ret = c4iw_ofld_send(&rhp->rdev, skb); ··· 1279 1279 FW_WR_FLOWID_V(qhp->ep->hwtid) | 1280 1280 FW_WR_LEN16_V(DIV_ROUND_UP(sizeof(*wqe), 16))); 1281 1281 1282 - wqe->cookie = (unsigned long) &qhp->ep->com.wr_wait; 1282 + wqe->cookie = (uintptr_t)&qhp->ep->com.wr_wait; 1283 1283 1284 1284 wqe->u.init.type = FW_RI_TYPE_INIT; 1285 1285 wqe->u.init.mpareqbit_p2ptype = ··· 1766 1766 mm2->len = PAGE_ALIGN(qhp->wq.rq.memsize); 1767 1767 insert_mmap(ucontext, mm2); 1768 1768 mm3->key = uresp.sq_db_gts_key; 1769 - mm3->addr = (__force unsigned long) qhp->wq.sq.udb; 1769 + mm3->addr = (__force unsigned long)qhp->wq.sq.udb; 1770 1770 mm3->len = PAGE_SIZE; 1771 1771 insert_mmap(ucontext, mm3); 1772 1772 mm4->key = uresp.rq_db_gts_key; 1773 - mm4->addr = (__force unsigned long) qhp->wq.rq.udb; 1773 + mm4->addr = (__force unsigned long)qhp->wq.rq.udb; 1774 1774 mm4->len = PAGE_SIZE; 1775 1775 insert_mmap(ucontext, mm4); 1776 1776 if (mm5) {

+4 -3

drivers/infiniband/hw/cxgb4/t4.h

··· 539 539 size_t memsize; 540 540 __be64 bits_type_ts; 541 541 u32 cqid; 542 + u32 qid_mask; 542 543 int vector; 543 544 u16 size; /* including status page */ 544 545 u16 cidx; ··· 564 563 set_bit(CQ_ARMED, &cq->flags); 565 564 while (cq->cidx_inc > CIDXINC_M) { 566 565 val = SEINTARM_V(0) | CIDXINC_V(CIDXINC_M) | TIMERREG_V(7) | 567 - INGRESSQID_V(cq->cqid); 566 + INGRESSQID_V(cq->cqid & cq->qid_mask); 568 567 writel(val, cq->gts); 569 568 cq->cidx_inc -= CIDXINC_M; 570 569 } 571 570 val = SEINTARM_V(se) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(6) | 572 - INGRESSQID_V(cq->cqid); 571 + INGRESSQID_V(cq->cqid & cq->qid_mask); 573 572 writel(val, cq->gts); 574 573 cq->cidx_inc = 0; 575 574 return 0; ··· 602 601 u32 val; 603 602 604 603 val = SEINTARM_V(0) | CIDXINC_V(cq->cidx_inc) | TIMERREG_V(7) | 605 - INGRESSQID_V(cq->cqid); 604 + INGRESSQID_V(cq->cqid & cq->qid_mask); 606 605 writel(val, cq->gts); 607 606 cq->cidx_inc = 0; 608 607 }

+3 -1

drivers/infiniband/hw/cxgb4/t4fw_ri_api.h

··· 848 848 #define CONG_CNTRL_V(x) ((x) << CONG_CNTRL_S) 849 849 #define CONG_CNTRL_G(x) (((x) >> CONG_CNTRL_S) & CONG_CNTRL_M) 850 850 851 - #define CONG_CNTRL_VALID (1 << 18) 851 + #define T5_ISS_S 18 852 + #define T5_ISS_V(x) ((x) << T5_ISS_S) 853 + #define T5_ISS_F T5_ISS_V(1U) 852 854 853 855 #endif /* _T4FW_RI_API_H_ */

+1

drivers/infiniband/hw/nes/nes.c

··· 116 116 [RDMA_NL_IWPM_REG_PID] = {.dump = iwpm_register_pid_cb}, 117 117 [RDMA_NL_IWPM_ADD_MAPPING] = {.dump = iwpm_add_mapping_cb}, 118 118 [RDMA_NL_IWPM_QUERY_MAPPING] = {.dump = iwpm_add_and_query_mapping_cb}, 119 + [RDMA_NL_IWPM_REMOTE_INFO] = {.dump = iwpm_remote_info_cb}, 119 120 [RDMA_NL_IWPM_HANDLE_ERR] = {.dump = iwpm_mapping_error_cb}, 120 121 [RDMA_NL_IWPM_MAPINFO] = {.dump = iwpm_mapping_info_cb}, 121 122 [RDMA_NL_IWPM_MAPINFO_NUM] = {.dump = iwpm_ack_mapping_info_cb}

+47 -16

drivers/infiniband/hw/nes/nes_cm.c

··· 596 596 memcpy(pm_msg->if_name, nesvnic->netdev->name, IWPM_IFNAME_SIZE); 597 597 } 598 598 599 + static void record_sockaddr_info(struct sockaddr_storage *addr_info, 600 + nes_addr_t *ip_addr, u16 *port_num) 601 + { 602 + struct sockaddr_in *in_addr = (struct sockaddr_in *)addr_info; 603 + 604 + if (in_addr->sin_family == AF_INET) { 605 + *ip_addr = ntohl(in_addr->sin_addr.s_addr); 606 + *port_num = ntohs(in_addr->sin_port); 607 + } 608 + } 609 + 599 610 /* 600 611 * nes_record_pm_msg - Save the received mapping info 601 612 */ 602 613 static void nes_record_pm_msg(struct nes_cm_info *cm_info, 603 614 struct iwpm_sa_data *pm_msg) 604 615 { 605 - struct sockaddr_in *mapped_loc_addr = 606 - (struct sockaddr_in *)&pm_msg->mapped_loc_addr; 607 - struct sockaddr_in *mapped_rem_addr = 608 - (struct sockaddr_in *)&pm_msg->mapped_rem_addr; 616 + record_sockaddr_info(&pm_msg->mapped_loc_addr, 617 + &cm_info->mapped_loc_addr, &cm_info->mapped_loc_port); 609 618 610 - if (mapped_loc_addr->sin_family == AF_INET) { 611 - cm_info->mapped_loc_addr = 612 - ntohl(mapped_loc_addr->sin_addr.s_addr); 613 - cm_info->mapped_loc_port = ntohs(mapped_loc_addr->sin_port); 614 - } 615 - if (mapped_rem_addr->sin_family == AF_INET) { 616 - cm_info->mapped_rem_addr = 617 - ntohl(mapped_rem_addr->sin_addr.s_addr); 618 - cm_info->mapped_rem_port = ntohs(mapped_rem_addr->sin_port); 619 - } 619 + record_sockaddr_info(&pm_msg->mapped_rem_addr, 620 + &cm_info->mapped_rem_addr, &cm_info->mapped_rem_port); 621 + } 622 + 623 + /* 624 + * nes_get_reminfo - Get the address info of the remote connecting peer 625 + */ 626 + static int nes_get_remote_addr(struct nes_cm_node *cm_node) 627 + { 628 + struct sockaddr_storage mapped_loc_addr, mapped_rem_addr; 629 + struct sockaddr_storage remote_addr; 630 + int ret; 631 + 632 + nes_create_sockaddr(htonl(cm_node->mapped_loc_addr), 633 + htons(cm_node->mapped_loc_port), &mapped_loc_addr); 634 + nes_create_sockaddr(htonl(cm_node->mapped_rem_addr), 635 + htons(cm_node->mapped_rem_port), &mapped_rem_addr); 636 + 637 + ret = iwpm_get_remote_info(&mapped_loc_addr, &mapped_rem_addr, 638 + &remote_addr, RDMA_NL_NES); 639 + if (ret) 640 + nes_debug(NES_DBG_CM, "Unable to find remote peer address info\n"); 641 + else 642 + record_sockaddr_info(&remote_addr, &cm_node->rem_addr, 643 + &cm_node->rem_port); 644 + return ret; 620 645 } 621 646 622 647 /** ··· 1591 1566 return NULL; 1592 1567 1593 1568 /* set our node specific transport info */ 1594 - cm_node->loc_addr = cm_info->loc_addr; 1569 + if (listener) { 1570 + cm_node->loc_addr = listener->loc_addr; 1571 + cm_node->loc_port = listener->loc_port; 1572 + } else { 1573 + cm_node->loc_addr = cm_info->loc_addr; 1574 + cm_node->loc_port = cm_info->loc_port; 1575 + } 1595 1576 cm_node->rem_addr = cm_info->rem_addr; 1596 - cm_node->loc_port = cm_info->loc_port; 1597 1577 cm_node->rem_port = cm_info->rem_port; 1598 1578 1599 1579 cm_node->mapped_loc_addr = cm_info->mapped_loc_addr; ··· 2181 2151 cm_node->state = NES_CM_STATE_ESTABLISHED; 2182 2152 if (datasize) { 2183 2153 cm_node->tcp_cntxt.rcv_nxt = inc_sequence + datasize; 2154 + nes_get_remote_addr(cm_node); 2184 2155 handle_rcv_mpa(cm_node, skb); 2185 2156 } else { /* rcvd ACK only */ 2186 2157 dev_kfree_skb_any(skb);

-1

drivers/infiniband/hw/qib/qib.h

··· 1136 1136 extern u32 qib_cpulist_count; 1137 1137 extern unsigned long *qib_cpulist; 1138 1138 1139 - extern unsigned qib_wc_pat; 1140 1139 extern unsigned qib_cc_table_size; 1141 1140 int qib_init(struct qib_devdata *, int); 1142 1141 int init_chip_wc_pat(struct qib_devdata *dd, u32);

+2 -1

drivers/infiniband/hw/qib/qib_file_ops.c

··· 835 835 vma->vm_flags &= ~VM_MAYREAD; 836 836 vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND; 837 837 838 - if (qib_wc_pat) 838 + /* We used PAT if wc_cookie == 0 */ 839 + if (!dd->wc_cookie) 839 840 vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); 840 841 841 842 ret = io_remap_pfn_range(vma, vma->vm_start, phys >> PAGE_SHIFT,

+3 -5

drivers/infiniband/hw/qib/qib_iba6120.c

··· 3315 3315 qib_6120_config_ctxts(dd); 3316 3316 qib_set_ctxtcnt(dd); 3317 3317 3318 - if (qib_wc_pat) { 3319 - ret = init_chip_wc_pat(dd, 0); 3320 - if (ret) 3321 - goto bail; 3322 - } 3318 + ret = init_chip_wc_pat(dd, 0); 3319 + if (ret) 3320 + goto bail; 3323 3321 set_6120_baseaddrs(dd); /* set chip access pointers now */ 3324 3322 3325 3323 ret = 0;

+3 -5

drivers/infiniband/hw/qib/qib_iba7220.c

··· 4126 4126 qib_7220_config_ctxts(dd); 4127 4127 qib_set_ctxtcnt(dd); /* needed for PAT setup */ 4128 4128 4129 - if (qib_wc_pat) { 4130 - ret = init_chip_wc_pat(dd, 0); 4131 - if (ret) 4132 - goto bail; 4133 - } 4129 + ret = init_chip_wc_pat(dd, 0); 4130 + if (ret) 4131 + goto bail; 4134 4132 set_7220_baseaddrs(dd); /* set chip access pointers now */ 4135 4133 4136 4134 ret = 0;

+20 -21

drivers/infiniband/hw/qib/qib_iba7322.c

··· 6429 6429 unsigned features, pidx, sbufcnt; 6430 6430 int ret, mtu; 6431 6431 u32 sbufs, updthresh; 6432 + resource_size_t vl15off; 6432 6433 6433 6434 /* pport structs are contiguous, allocated after devdata */ 6434 6435 ppd = (struct qib_pportdata *)(dd + 1); ··· 6678 6677 qib_7322_config_ctxts(dd); 6679 6678 qib_set_ctxtcnt(dd); 6680 6679 6681 - if (qib_wc_pat) { 6682 - resource_size_t vl15off; 6683 - /* 6684 - * We do not set WC on the VL15 buffers to avoid 6685 - * a rare problem with unaligned writes from 6686 - * interrupt-flushed store buffers, so we need 6687 - * to map those separately here. We can't solve 6688 - * this for the rarely used mtrr case. 6689 - */ 6690 - ret = init_chip_wc_pat(dd, 0); 6691 - if (ret) 6692 - goto bail; 6680 + /* 6681 + * We do not set WC on the VL15 buffers to avoid 6682 + * a rare problem with unaligned writes from 6683 + * interrupt-flushed store buffers, so we need 6684 + * to map those separately here. We can't solve 6685 + * this for the rarely used mtrr case. 6686 + */ 6687 + ret = init_chip_wc_pat(dd, 0); 6688 + if (ret) 6689 + goto bail; 6693 6690 6694 - /* vl15 buffers start just after the 4k buffers */ 6695 - vl15off = dd->physaddr + (dd->piobufbase >> 32) + 6696 - dd->piobcnt4k * dd->align4k; 6697 - dd->piovl15base = ioremap_nocache(vl15off, 6698 - NUM_VL15_BUFS * dd->align4k); 6699 - if (!dd->piovl15base) { 6700 - ret = -ENOMEM; 6701 - goto bail; 6702 - } 6691 + /* vl15 buffers start just after the 4k buffers */ 6692 + vl15off = dd->physaddr + (dd->piobufbase >> 32) + 6693 + dd->piobcnt4k * dd->align4k; 6694 + dd->piovl15base = ioremap_nocache(vl15off, 6695 + NUM_VL15_BUFS * dd->align4k); 6696 + if (!dd->piovl15base) { 6697 + ret = -ENOMEM; 6698 + goto bail; 6703 6699 } 6700 + 6704 6701 qib_7322_set_baseaddrs(dd); /* set chip access pointers now */ 6705 6702 6706 6703 ret = 0;

+7 -19

drivers/infiniband/hw/qib/qib_init.c

··· 91 91 unsigned qib_cc_table_size; 92 92 module_param_named(cc_table_size, qib_cc_table_size, uint, S_IRUGO); 93 93 MODULE_PARM_DESC(cc_table_size, "Congestion control table entries 0 (CCA disabled - default), min = 128, max = 1984"); 94 - /* 95 - * qib_wc_pat parameter: 96 - * 0 is WC via MTRR 97 - * 1 is WC via PAT 98 - * If PAT initialization fails, code reverts back to MTRR 99 - */ 100 - unsigned qib_wc_pat = 1; /* default (1) is to use PAT, not MTRR */ 101 - module_param_named(wc_pat, qib_wc_pat, uint, S_IRUGO); 102 - MODULE_PARM_DESC(wc_pat, "enable write-combining via PAT mechanism"); 103 94 104 95 static void verify_interrupt(unsigned long); 105 96 ··· 1368 1377 spin_unlock(&dd->pport[pidx].cc_shadow_lock); 1369 1378 } 1370 1379 1371 - if (!qib_wc_pat) 1372 - qib_disable_wc(dd); 1380 + qib_disable_wc(dd); 1373 1381 1374 1382 if (dd->pioavailregs_dma) { 1375 1383 dma_free_coherent(&dd->pcidev->dev, PAGE_SIZE, ··· 1537 1547 goto bail; 1538 1548 } 1539 1549 1540 - if (!qib_wc_pat) { 1541 - ret = qib_enable_wc(dd); 1542 - if (ret) { 1543 - qib_dev_err(dd, 1544 - "Write combining not enabled (err %d): performance may be poor\n", 1545 - -ret); 1546 - ret = 0; 1547 - } 1550 + ret = qib_enable_wc(dd); 1551 + if (ret) { 1552 + qib_dev_err(dd, 1553 + "Write combining not enabled (err %d): performance may be poor\n", 1554 + -ret); 1555 + ret = 0; 1548 1556 } 1549 1557 1550 1558 qib_verify_pioperf(dd);

+4 -27

drivers/infiniband/hw/qib/qib_wc_x86_64.c

··· 116 116 } 117 117 118 118 if (!ret) { 119 - int cookie; 120 - 121 - cookie = mtrr_add(pioaddr, piolen, MTRR_TYPE_WRCOMB, 0); 122 - if (cookie < 0) { 123 - { 124 - qib_devinfo(dd->pcidev, 125 - "mtrr_add() WC for PIO bufs failed (%d)\n", 126 - cookie); 127 - ret = -EINVAL; 128 - } 129 - } else { 130 - dd->wc_cookie = cookie; 131 - dd->wc_base = (unsigned long) pioaddr; 132 - dd->wc_len = (unsigned long) piolen; 133 - } 119 + dd->wc_cookie = arch_phys_wc_add(pioaddr, piolen); 120 + if (dd->wc_cookie < 0) 121 + ret = -EINVAL; 134 122 } 135 123 136 124 return ret; ··· 130 142 */ 131 143 void qib_disable_wc(struct qib_devdata *dd) 132 144 { 133 - if (dd->wc_cookie) { 134 - int r; 135 - 136 - r = mtrr_del(dd->wc_cookie, dd->wc_base, 137 - dd->wc_len); 138 - if (r < 0) 139 - qib_devinfo(dd->pcidev, 140 - "mtrr_del(%lx, %lx, %lx) failed: %d\n", 141 - dd->wc_cookie, dd->wc_base, 142 - dd->wc_len, r); 143 - dd->wc_cookie = 0; /* even on failure */ 144 - } 145 + arch_phys_wc_del(dd->wc_cookie); 145 146 } 146 147 147 148 /**

+2 -2

drivers/infiniband/ulp/ipoib/ipoib_cm.c

··· 386 386 rx->rx_ring[i].mapping, 387 387 GFP_KERNEL)) { 388 388 ipoib_warn(priv, "failed to allocate receive buffer %d\n", i); 389 - ret = -ENOMEM; 390 - goto err_count; 389 + ret = -ENOMEM; 390 + goto err_count; 391 391 } 392 392 ret = ipoib_cm_post_receive_nonsrq(dev, rx, &t->wr, t->sge, i); 393 393 if (ret) {

+1 -2

include/rdma/ib_addr.h

··· 160 160 } 161 161 162 162 /* Important - sockaddr should be a union of sockaddr_in and sockaddr_in6 */ 163 - static inline int rdma_gid2ip(struct sockaddr *out, union ib_gid *gid) 163 + static inline void rdma_gid2ip(struct sockaddr *out, union ib_gid *gid) 164 164 { 165 165 if (ipv6_addr_v4mapped((struct in6_addr *)gid)) { 166 166 struct sockaddr_in *out_in = (struct sockaddr_in *)out; ··· 173 173 out_in->sin6_family = AF_INET6; 174 174 memcpy(&out_in->sin6_addr.s6_addr, gid->raw, 16); 175 175 } 176 - return 0; 177 176 } 178 177 179 178 static inline void iboe_addr_get_sgid(struct rdma_dev_addr *dev_addr,

+4 -3

include/rdma/ib_cm.h

··· 105 105 IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE = 216, 106 106 IB_CM_SIDR_REP_PRIVATE_DATA_SIZE = 136, 107 107 IB_CM_SIDR_REP_INFO_LENGTH = 72, 108 - IB_CM_COMPARE_SIZE = 64 108 + /* compare done u32 at a time */ 109 + IB_CM_COMPARE_SIZE = (64 / sizeof(u32)) 109 110 }; 110 111 111 112 struct ib_cm_id; ··· 338 337 #define IB_SDP_SERVICE_ID_MASK cpu_to_be64(0xFFFFFFFFFFFF0000ULL) 339 338 340 339 struct ib_cm_compare_data { 341 - u8 data[IB_CM_COMPARE_SIZE]; 342 - u8 mask[IB_CM_COMPARE_SIZE]; 340 + u32 data[IB_CM_COMPARE_SIZE]; 341 + u32 mask[IB_CM_COMPARE_SIZE]; 343 342 }; 344 343 345 344 /**

+25

include/rdma/iw_portmap.h

··· 148 148 int iwpm_add_and_query_mapping_cb(struct sk_buff *, struct netlink_callback *); 149 149 150 150 /** 151 + * iwpm_remote_info_cb - Process remote connecting peer address info, which 152 + * the port mapper has received from the connecting peer 153 + * 154 + * @cb: Contains the received message (payload and netlink header) 155 + * 156 + * Stores the IPv4/IPv6 address info in a hash table 157 + */ 158 + int iwpm_remote_info_cb(struct sk_buff *, struct netlink_callback *); 159 + 160 + /** 151 161 * iwpm_mapping_error_cb - Process port mapper notification for error 152 162 * 153 163 * @skb: ··· 183 173 * @cb: Contains the received message (payload and netlink header) 184 174 */ 185 175 int iwpm_ack_mapping_info_cb(struct sk_buff *, struct netlink_callback *); 176 + 177 + /** 178 + * iwpm_get_remote_info - Get the remote connecting peer address info 179 + * 180 + * @mapped_loc_addr: Mapped local address of the listening peer 181 + * @mapped_rem_addr: Mapped remote address of the connecting peer 182 + * @remote_addr: To store the remote address of the connecting peer 183 + * @nl_client: The index of the netlink client 184 + * 185 + * The remote address info is retrieved and provided to the client in 186 + * the remote_addr. After that it is removed from the hash table 187 + */ 188 + int iwpm_get_remote_info(struct sockaddr_storage *mapped_loc_addr, 189 + struct sockaddr_storage *mapped_rem_addr, 190 + struct sockaddr_storage *remote_addr, u8 nl_client); 186 191 187 192 /** 188 193 * iwpm_create_mapinfo - Store local and mapped IPv4/IPv6 address

+1

include/uapi/rdma/rdma_netlink.h

··· 37 37 RDMA_NL_IWPM_ADD_MAPPING, 38 38 RDMA_NL_IWPM_QUERY_MAPPING, 39 39 RDMA_NL_IWPM_REMOVE_MAPPING, 40 + RDMA_NL_IWPM_REMOTE_INFO, 40 41 RDMA_NL_IWPM_HANDLE_ERR, 41 42 RDMA_NL_IWPM_MAPINFO, 42 43 RDMA_NL_IWPM_MAPINFO_NUM,

Configure Feed

Configure Feed