1 /* 2 * Copyright (c) 2014 Chelsio, Inc. All rights reserved. 3 * Copyright (c) 2014 Intel Corporation. All rights reserved. 4 * 5 * This software is available to you under a choice of one of two 6 * licenses. You may choose to be licensed under the terms of the GNU 7 * General Public License (GPL) Version 2, available from the file 8 * COPYING in the main directory of this source tree, or the 9 * OpenIB.org BSD license below: 10 * 11 * Redistribution and use in source and binary forms, with or 12 * without modification, are permitted provided that the following 13 * conditions are met: 14 * 15 * - Redistributions of source code must retain the above 16 * copyright notice, this list of conditions and the following 17 * disclaimer. 18 * 19 * - Redistributions in binary form must reproduce the above 20 * copyright notice, this list of conditions and the following 21 * disclaimer in the documentation and/or other materials 22 * provided with the distribution. 23 * 24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 31 * SOFTWARE. 32 */ 33 34 #include "iwpm_util.h" 35 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) 40 #define IWPM_MSG_SIZE 512 41 42 static LIST_HEAD(iwpm_nlmsg_req_list); 43 static DEFINE_SPINLOCK(iwpm_nlmsg_req_lock); 44 45 static struct hlist_head *iwpm_hash_bucket; 46 static DEFINE_SPINLOCK(iwpm_mapinfo_lock); 47 48 static struct hlist_head *iwpm_reminfo_bucket; 49 static DEFINE_SPINLOCK(iwpm_reminfo_lock); 50 51 static DEFINE_MUTEX(iwpm_admin_lock); 52 static struct iwpm_admin_data iwpm_admin; 53 54 int iwpm_init(u8 nl_client) 55 { 56 int ret = 0; 57 mutex_lock(&iwpm_admin_lock); 58 if (atomic_read(&iwpm_admin.refcount) == 0) { 59 iwpm_hash_bucket = kzalloc(IWPM_MAPINFO_HASH_SIZE * 60 sizeof(struct hlist_head), GFP_KERNEL); 61 if (!iwpm_hash_bucket) { 62 ret = -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 goto init_exit; 71 } 72 } 73 atomic_inc(&iwpm_admin.refcount); 74 init_exit: 75 mutex_unlock(&iwpm_admin_lock); 76 if (!ret) { 77 iwpm_set_valid(nl_client, 1); 78 iwpm_set_registration(nl_client, IWPM_REG_UNDEF); 79 pr_debug("%s: Mapinfo and reminfo tables are created\n", 80 __func__); 81 } 82 return ret; 83 } 84 85 static void free_hash_bucket(void); 86 static void free_reminfo_bucket(void); 87 88 int iwpm_exit(u8 nl_client) 89 { 90 91 if (!iwpm_valid_client(nl_client)) 92 return -EINVAL; 93 mutex_lock(&iwpm_admin_lock); 94 if (atomic_read(&iwpm_admin.refcount) == 0) { 95 mutex_unlock(&iwpm_admin_lock); 96 pr_err("%s Incorrect usage - negative refcount\n", __func__); 97 return -EINVAL; 98 } 99 if (atomic_dec_and_test(&iwpm_admin.refcount)) { 100 free_hash_bucket(); 101 free_reminfo_bucket(); 102 pr_debug("%s: Resources are destroyed\n", __func__); 103 } 104 mutex_unlock(&iwpm_admin_lock); 105 iwpm_set_valid(nl_client, 0); 106 iwpm_set_registration(nl_client, IWPM_REG_UNDEF); 107 return 0; 108 } 109 110 static struct hlist_head *get_mapinfo_hash_bucket(struct sockaddr_storage *, 111 struct sockaddr_storage *); 112 113 int iwpm_create_mapinfo(struct sockaddr_storage *local_sockaddr, 114 struct sockaddr_storage *mapped_sockaddr, 115 u8 nl_client) 116 { 117 struct hlist_head *hash_bucket_head = NULL; 118 struct iwpm_mapping_info *map_info; 119 unsigned long flags; 120 int ret = -EINVAL; 121 122 if (!iwpm_valid_client(nl_client)) 123 return ret; 124 map_info = kzalloc(sizeof(struct iwpm_mapping_info), GFP_KERNEL); 125 if (!map_info) 126 return -ENOMEM; 127 128 memcpy(&map_info->local_sockaddr, local_sockaddr, 129 sizeof(struct sockaddr_storage)); 130 memcpy(&map_info->mapped_sockaddr, mapped_sockaddr, 131 sizeof(struct sockaddr_storage)); 132 map_info->nl_client = nl_client; 133 134 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 135 if (iwpm_hash_bucket) { 136 hash_bucket_head = get_mapinfo_hash_bucket( 137 &map_info->local_sockaddr, 138 &map_info->mapped_sockaddr); 139 if (hash_bucket_head) { 140 hlist_add_head(&map_info->hlist_node, hash_bucket_head); 141 ret = 0; 142 } 143 } 144 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 145 146 if (!hash_bucket_head) 147 kfree(map_info); 148 return ret; 149 } 150 151 int iwpm_remove_mapinfo(struct sockaddr_storage *local_sockaddr, 152 struct sockaddr_storage *mapped_local_addr) 153 { 154 struct hlist_node *tmp_hlist_node; 155 struct hlist_head *hash_bucket_head; 156 struct iwpm_mapping_info *map_info = NULL; 157 unsigned long flags; 158 int ret = -EINVAL; 159 160 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 161 if (iwpm_hash_bucket) { 162 hash_bucket_head = get_mapinfo_hash_bucket( 163 local_sockaddr, 164 mapped_local_addr); 165 if (!hash_bucket_head) 166 goto remove_mapinfo_exit; 167 168 hlist_for_each_entry_safe(map_info, tmp_hlist_node, 169 hash_bucket_head, hlist_node) { 170 171 if (!iwpm_compare_sockaddr(&map_info->mapped_sockaddr, 172 mapped_local_addr)) { 173 174 hlist_del_init(&map_info->hlist_node); 175 kfree(map_info); 176 ret = 0; 177 break; 178 } 179 } 180 } 181 remove_mapinfo_exit: 182 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 183 return ret; 184 } 185 186 static void free_hash_bucket(void) 187 { 188 struct hlist_node *tmp_hlist_node; 189 struct iwpm_mapping_info *map_info; 190 unsigned long flags; 191 int i; 192 193 /* remove all the mapinfo data from the list */ 194 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 195 for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 196 hlist_for_each_entry_safe(map_info, tmp_hlist_node, 197 &iwpm_hash_bucket[i], hlist_node) { 198 199 hlist_del_init(&map_info->hlist_node); 200 kfree(map_info); 201 } 202 } 203 /* free the hash list */ 204 kfree(iwpm_hash_bucket); 205 iwpm_hash_bucket = NULL; 206 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 207 } 208 209 static void free_reminfo_bucket(void) 210 { 211 struct hlist_node *tmp_hlist_node; 212 struct iwpm_remote_info *rem_info; 213 unsigned long flags; 214 int i; 215 216 /* remove all the remote info from the list */ 217 spin_lock_irqsave(&iwpm_reminfo_lock, flags); 218 for (i = 0; i < IWPM_REMINFO_HASH_SIZE; i++) { 219 hlist_for_each_entry_safe(rem_info, tmp_hlist_node, 220 &iwpm_reminfo_bucket[i], hlist_node) { 221 222 hlist_del_init(&rem_info->hlist_node); 223 kfree(rem_info); 224 } 225 } 226 /* free the hash list */ 227 kfree(iwpm_reminfo_bucket); 228 iwpm_reminfo_bucket = NULL; 229 spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 230 } 231 232 static struct hlist_head *get_reminfo_hash_bucket(struct sockaddr_storage *, 233 struct sockaddr_storage *); 234 235 void iwpm_add_remote_info(struct iwpm_remote_info *rem_info) 236 { 237 struct hlist_head *hash_bucket_head; 238 unsigned long flags; 239 240 spin_lock_irqsave(&iwpm_reminfo_lock, flags); 241 if (iwpm_reminfo_bucket) { 242 hash_bucket_head = get_reminfo_hash_bucket( 243 &rem_info->mapped_loc_sockaddr, 244 &rem_info->mapped_rem_sockaddr); 245 if (hash_bucket_head) 246 hlist_add_head(&rem_info->hlist_node, hash_bucket_head); 247 } 248 spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 249 } 250 251 int iwpm_get_remote_info(struct sockaddr_storage *mapped_loc_addr, 252 struct sockaddr_storage *mapped_rem_addr, 253 struct sockaddr_storage *remote_addr, 254 u8 nl_client) 255 { 256 struct hlist_node *tmp_hlist_node; 257 struct hlist_head *hash_bucket_head; 258 struct iwpm_remote_info *rem_info = NULL; 259 unsigned long flags; 260 int ret = -EINVAL; 261 262 if (!iwpm_valid_client(nl_client)) { 263 pr_info("%s: Invalid client = %d\n", __func__, nl_client); 264 return ret; 265 } 266 spin_lock_irqsave(&iwpm_reminfo_lock, flags); 267 if (iwpm_reminfo_bucket) { 268 hash_bucket_head = get_reminfo_hash_bucket( 269 mapped_loc_addr, 270 mapped_rem_addr); 271 if (!hash_bucket_head) 272 goto get_remote_info_exit; 273 hlist_for_each_entry_safe(rem_info, tmp_hlist_node, 274 hash_bucket_head, hlist_node) { 275 276 if (!iwpm_compare_sockaddr(&rem_info->mapped_loc_sockaddr, 277 mapped_loc_addr) && 278 !iwpm_compare_sockaddr(&rem_info->mapped_rem_sockaddr, 279 mapped_rem_addr)) { 280 281 memcpy(remote_addr, &rem_info->remote_sockaddr, 282 sizeof(struct sockaddr_storage)); 283 iwpm_print_sockaddr(remote_addr, 284 "get_remote_info: Remote sockaddr:"); 285 286 hlist_del_init(&rem_info->hlist_node); 287 kfree(rem_info); 288 ret = 0; 289 break; 290 } 291 } 292 } 293 get_remote_info_exit: 294 spin_unlock_irqrestore(&iwpm_reminfo_lock, flags); 295 return ret; 296 } 297 298 struct iwpm_nlmsg_request *iwpm_get_nlmsg_request(__u32 nlmsg_seq, 299 u8 nl_client, gfp_t gfp) 300 { 301 struct iwpm_nlmsg_request *nlmsg_request = NULL; 302 unsigned long flags; 303 304 nlmsg_request = kzalloc(sizeof(struct iwpm_nlmsg_request), gfp); 305 if (!nlmsg_request) 306 return NULL; 307 308 spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags); 309 list_add_tail(&nlmsg_request->inprocess_list, &iwpm_nlmsg_req_list); 310 spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags); 311 312 kref_init(&nlmsg_request->kref); 313 kref_get(&nlmsg_request->kref); 314 nlmsg_request->nlmsg_seq = nlmsg_seq; 315 nlmsg_request->nl_client = nl_client; 316 nlmsg_request->request_done = 0; 317 nlmsg_request->err_code = 0; 318 sema_init(&nlmsg_request->sem, 1); 319 down(&nlmsg_request->sem); 320 return nlmsg_request; 321 } 322 323 void iwpm_free_nlmsg_request(struct kref *kref) 324 { 325 struct iwpm_nlmsg_request *nlmsg_request; 326 unsigned long flags; 327 328 nlmsg_request = container_of(kref, struct iwpm_nlmsg_request, kref); 329 330 spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags); 331 list_del_init(&nlmsg_request->inprocess_list); 332 spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags); 333 334 if (!nlmsg_request->request_done) 335 pr_debug("%s Freeing incomplete nlmsg request (seq = %u).\n", 336 __func__, nlmsg_request->nlmsg_seq); 337 kfree(nlmsg_request); 338 } 339 340 struct iwpm_nlmsg_request *iwpm_find_nlmsg_request(__u32 echo_seq) 341 { 342 struct iwpm_nlmsg_request *nlmsg_request; 343 struct iwpm_nlmsg_request *found_request = NULL; 344 unsigned long flags; 345 346 spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags); 347 list_for_each_entry(nlmsg_request, &iwpm_nlmsg_req_list, 348 inprocess_list) { 349 if (nlmsg_request->nlmsg_seq == echo_seq) { 350 found_request = nlmsg_request; 351 kref_get(&nlmsg_request->kref); 352 break; 353 } 354 } 355 spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags); 356 return found_request; 357 } 358 359 int iwpm_wait_complete_req(struct iwpm_nlmsg_request *nlmsg_request) 360 { 361 int ret; 362 363 ret = down_timeout(&nlmsg_request->sem, IWPM_NL_TIMEOUT); 364 if (ret) { 365 ret = -EINVAL; 366 pr_info("%s: Timeout %d sec for netlink request (seq = %u)\n", 367 __func__, (IWPM_NL_TIMEOUT/HZ), nlmsg_request->nlmsg_seq); 368 } else { 369 ret = nlmsg_request->err_code; 370 } 371 kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request); 372 return ret; 373 } 374 375 int iwpm_get_nlmsg_seq(void) 376 { 377 return atomic_inc_return(&iwpm_admin.nlmsg_seq); 378 } 379 380 int iwpm_valid_client(u8 nl_client) 381 { 382 return iwpm_admin.client_list[nl_client]; 383 } 384 385 void iwpm_set_valid(u8 nl_client, int valid) 386 { 387 iwpm_admin.client_list[nl_client] = valid; 388 } 389 390 /* valid client */ 391 u32 iwpm_get_registration(u8 nl_client) 392 { 393 return iwpm_admin.reg_list[nl_client]; 394 } 395 396 /* valid client */ 397 void iwpm_set_registration(u8 nl_client, u32 reg) 398 { 399 iwpm_admin.reg_list[nl_client] = reg; 400 } 401 402 /* valid client */ 403 u32 iwpm_check_registration(u8 nl_client, u32 reg) 404 { 405 return (iwpm_get_registration(nl_client) & reg); 406 } 407 408 int iwpm_compare_sockaddr(struct sockaddr_storage *a_sockaddr, 409 struct sockaddr_storage *b_sockaddr) 410 { 411 if (a_sockaddr->ss_family != b_sockaddr->ss_family) 412 return 1; 413 if (a_sockaddr->ss_family == AF_INET) { 414 struct sockaddr_in *a4_sockaddr = 415 (struct sockaddr_in *)a_sockaddr; 416 struct sockaddr_in *b4_sockaddr = 417 (struct sockaddr_in *)b_sockaddr; 418 if (!memcmp(&a4_sockaddr->sin_addr, 419 &b4_sockaddr->sin_addr, sizeof(struct in_addr)) 420 && a4_sockaddr->sin_port == b4_sockaddr->sin_port) 421 return 0; 422 423 } else if (a_sockaddr->ss_family == AF_INET6) { 424 struct sockaddr_in6 *a6_sockaddr = 425 (struct sockaddr_in6 *)a_sockaddr; 426 struct sockaddr_in6 *b6_sockaddr = 427 (struct sockaddr_in6 *)b_sockaddr; 428 if (!memcmp(&a6_sockaddr->sin6_addr, 429 &b6_sockaddr->sin6_addr, sizeof(struct in6_addr)) 430 && a6_sockaddr->sin6_port == b6_sockaddr->sin6_port) 431 return 0; 432 433 } else { 434 pr_err("%s: Invalid sockaddr family\n", __func__); 435 } 436 return 1; 437 } 438 439 struct sk_buff *iwpm_create_nlmsg(u32 nl_op, struct nlmsghdr **nlh, 440 int nl_client) 441 { 442 struct sk_buff *skb = NULL; 443 444 skb = dev_alloc_skb(IWPM_MSG_SIZE); 445 if (!skb) 446 goto create_nlmsg_exit; 447 448 if (!(ibnl_put_msg(skb, nlh, 0, 0, nl_client, nl_op, 449 NLM_F_REQUEST))) { 450 pr_warn("%s: Unable to put the nlmsg header\n", __func__); 451 dev_kfree_skb(skb); 452 skb = NULL; 453 } 454 create_nlmsg_exit: 455 return skb; 456 } 457 458 int iwpm_parse_nlmsg(struct netlink_callback *cb, int policy_max, 459 const struct nla_policy *nlmsg_policy, 460 struct nlattr *nltb[], const char *msg_type) 461 { 462 int nlh_len = 0; 463 int ret; 464 const char *err_str = ""; 465 466 ret = nlmsg_validate(cb->nlh, nlh_len, policy_max - 1, nlmsg_policy, 467 NULL); 468 if (ret) { 469 err_str = "Invalid attribute"; 470 goto parse_nlmsg_error; 471 } 472 ret = nlmsg_parse(cb->nlh, nlh_len, nltb, policy_max - 1, 473 nlmsg_policy, NULL); 474 if (ret) { 475 err_str = "Unable to parse the nlmsg"; 476 goto parse_nlmsg_error; 477 } 478 ret = iwpm_validate_nlmsg_attr(nltb, policy_max); 479 if (ret) { 480 err_str = "Invalid NULL attribute"; 481 goto parse_nlmsg_error; 482 } 483 return 0; 484 parse_nlmsg_error: 485 pr_warn("%s: %s (msg type %s ret = %d)\n", 486 __func__, err_str, msg_type, ret); 487 return ret; 488 } 489 490 void iwpm_print_sockaddr(struct sockaddr_storage *sockaddr, char *msg) 491 { 492 struct sockaddr_in6 *sockaddr_v6; 493 struct sockaddr_in *sockaddr_v4; 494 495 switch (sockaddr->ss_family) { 496 case AF_INET: 497 sockaddr_v4 = (struct sockaddr_in *)sockaddr; 498 pr_debug("%s IPV4 %pI4: %u(0x%04X)\n", 499 msg, &sockaddr_v4->sin_addr, 500 ntohs(sockaddr_v4->sin_port), 501 ntohs(sockaddr_v4->sin_port)); 502 break; 503 case AF_INET6: 504 sockaddr_v6 = (struct sockaddr_in6 *)sockaddr; 505 pr_debug("%s IPV6 %pI6: %u(0x%04X)\n", 506 msg, &sockaddr_v6->sin6_addr, 507 ntohs(sockaddr_v6->sin6_port), 508 ntohs(sockaddr_v6->sin6_port)); 509 break; 510 default: 511 break; 512 } 513 } 514 515 static u32 iwpm_ipv6_jhash(struct sockaddr_in6 *ipv6_sockaddr) 516 { 517 u32 ipv6_hash = jhash(&ipv6_sockaddr->sin6_addr, sizeof(struct in6_addr), 0); 518 u32 hash = jhash_2words(ipv6_hash, (__force u32) ipv6_sockaddr->sin6_port, 0); 519 return hash; 520 } 521 522 static u32 iwpm_ipv4_jhash(struct sockaddr_in *ipv4_sockaddr) 523 { 524 u32 ipv4_hash = jhash(&ipv4_sockaddr->sin_addr, sizeof(struct in_addr), 0); 525 u32 hash = jhash_2words(ipv4_hash, (__force u32) ipv4_sockaddr->sin_port, 0); 526 return hash; 527 } 528 529 static int get_hash_bucket(struct sockaddr_storage *a_sockaddr, 530 struct sockaddr_storage *b_sockaddr, u32 *hash) 531 { 532 u32 a_hash, b_hash; 533 534 if (a_sockaddr->ss_family == AF_INET) { 535 a_hash = iwpm_ipv4_jhash((struct sockaddr_in *) a_sockaddr); 536 b_hash = iwpm_ipv4_jhash((struct sockaddr_in *) b_sockaddr); 537 538 } else if (a_sockaddr->ss_family == AF_INET6) { 539 a_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) a_sockaddr); 540 b_hash = iwpm_ipv6_jhash((struct sockaddr_in6 *) b_sockaddr); 541 } else { 542 pr_err("%s: Invalid sockaddr family\n", __func__); 543 return -EINVAL; 544 } 545 546 if (a_hash == b_hash) /* if port mapper isn't available */ 547 *hash = a_hash; 548 else 549 *hash = jhash_2words(a_hash, b_hash, 0); 550 return 0; 551 } 552 553 static struct hlist_head *get_mapinfo_hash_bucket(struct sockaddr_storage 554 *local_sockaddr, struct sockaddr_storage 555 *mapped_sockaddr) 556 { 557 u32 hash; 558 int ret; 559 560 ret = get_hash_bucket(local_sockaddr, mapped_sockaddr, &hash); 561 if (ret) 562 return NULL; 563 return &iwpm_hash_bucket[hash & IWPM_MAPINFO_HASH_MASK]; 564 } 565 566 static struct hlist_head *get_reminfo_hash_bucket(struct sockaddr_storage 567 *mapped_loc_sockaddr, struct sockaddr_storage 568 *mapped_rem_sockaddr) 569 { 570 u32 hash; 571 int ret; 572 573 ret = get_hash_bucket(mapped_loc_sockaddr, mapped_rem_sockaddr, &hash); 574 if (ret) 575 return NULL; 576 return &iwpm_reminfo_bucket[hash & IWPM_REMINFO_HASH_MASK]; 577 } 578 579 static int send_mapinfo_num(u32 mapping_num, u8 nl_client, int iwpm_pid) 580 { 581 struct sk_buff *skb = NULL; 582 struct nlmsghdr *nlh; 583 u32 msg_seq; 584 const char *err_str = ""; 585 int ret = -EINVAL; 586 587 skb = iwpm_create_nlmsg(RDMA_NL_IWPM_MAPINFO_NUM, &nlh, nl_client); 588 if (!skb) { 589 err_str = "Unable to create a nlmsg"; 590 goto mapinfo_num_error; 591 } 592 nlh->nlmsg_seq = iwpm_get_nlmsg_seq(); 593 msg_seq = 0; 594 err_str = "Unable to put attribute of mapinfo number nlmsg"; 595 ret = ibnl_put_attr(skb, nlh, sizeof(u32), &msg_seq, IWPM_NLA_MAPINFO_SEQ); 596 if (ret) 597 goto mapinfo_num_error; 598 ret = ibnl_put_attr(skb, nlh, sizeof(u32), 599 &mapping_num, IWPM_NLA_MAPINFO_SEND_NUM); 600 if (ret) 601 goto mapinfo_num_error; 602 603 nlmsg_end(skb, nlh); 604 605 ret = rdma_nl_unicast(skb, iwpm_pid); 606 if (ret) { 607 skb = NULL; 608 err_str = "Unable to send a nlmsg"; 609 goto mapinfo_num_error; 610 } 611 pr_debug("%s: Sent mapping number = %d\n", __func__, mapping_num); 612 return 0; 613 mapinfo_num_error: 614 pr_info("%s: %s\n", __func__, err_str); 615 if (skb) 616 dev_kfree_skb(skb); 617 return ret; 618 } 619 620 static int send_nlmsg_done(struct sk_buff *skb, u8 nl_client, int iwpm_pid) 621 { 622 struct nlmsghdr *nlh = NULL; 623 int ret = 0; 624 625 if (!skb) 626 return ret; 627 if (!(ibnl_put_msg(skb, &nlh, 0, 0, nl_client, 628 RDMA_NL_IWPM_MAPINFO, NLM_F_MULTI))) { 629 pr_warn("%s Unable to put NLMSG_DONE\n", __func__); 630 dev_kfree_skb(skb); 631 return -ENOMEM; 632 } 633 nlh->nlmsg_type = NLMSG_DONE; 634 ret = rdma_nl_unicast(skb, iwpm_pid); 635 if (ret) 636 pr_warn("%s Unable to send a nlmsg\n", __func__); 637 return ret; 638 } 639 640 int iwpm_send_mapinfo(u8 nl_client, int iwpm_pid) 641 { 642 struct iwpm_mapping_info *map_info; 643 struct sk_buff *skb = NULL; 644 struct nlmsghdr *nlh; 645 int skb_num = 0, mapping_num = 0; 646 int i = 0, nlmsg_bytes = 0; 647 unsigned long flags; 648 const char *err_str = ""; 649 int ret; 650 651 skb = dev_alloc_skb(NLMSG_GOODSIZE); 652 if (!skb) { 653 ret = -ENOMEM; 654 err_str = "Unable to allocate skb"; 655 goto send_mapping_info_exit; 656 } 657 skb_num++; 658 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 659 ret = -EINVAL; 660 for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 661 hlist_for_each_entry(map_info, &iwpm_hash_bucket[i], 662 hlist_node) { 663 if (map_info->nl_client != nl_client) 664 continue; 665 nlh = NULL; 666 if (!(ibnl_put_msg(skb, &nlh, 0, 0, nl_client, 667 RDMA_NL_IWPM_MAPINFO, NLM_F_MULTI))) { 668 ret = -ENOMEM; 669 err_str = "Unable to put the nlmsg header"; 670 goto send_mapping_info_unlock; 671 } 672 err_str = "Unable to put attribute of the nlmsg"; 673 ret = ibnl_put_attr(skb, nlh, 674 sizeof(struct sockaddr_storage), 675 &map_info->local_sockaddr, 676 IWPM_NLA_MAPINFO_LOCAL_ADDR); 677 if (ret) 678 goto send_mapping_info_unlock; 679 680 ret = ibnl_put_attr(skb, nlh, 681 sizeof(struct sockaddr_storage), 682 &map_info->mapped_sockaddr, 683 IWPM_NLA_MAPINFO_MAPPED_ADDR); 684 if (ret) 685 goto send_mapping_info_unlock; 686 687 nlmsg_end(skb, nlh); 688 689 iwpm_print_sockaddr(&map_info->local_sockaddr, 690 "send_mapping_info: Local sockaddr:"); 691 iwpm_print_sockaddr(&map_info->mapped_sockaddr, 692 "send_mapping_info: Mapped local sockaddr:"); 693 mapping_num++; 694 nlmsg_bytes += nlh->nlmsg_len; 695 696 /* check if all mappings can fit in one skb */ 697 if (NLMSG_GOODSIZE - nlmsg_bytes < nlh->nlmsg_len * 2) { 698 /* and leave room for NLMSG_DONE */ 699 nlmsg_bytes = 0; 700 skb_num++; 701 spin_unlock_irqrestore(&iwpm_mapinfo_lock, 702 flags); 703 /* send the skb */ 704 ret = send_nlmsg_done(skb, nl_client, iwpm_pid); 705 skb = NULL; 706 if (ret) { 707 err_str = "Unable to send map info"; 708 goto send_mapping_info_exit; 709 } 710 if (skb_num == IWPM_MAPINFO_SKB_COUNT) { 711 ret = -ENOMEM; 712 err_str = "Insufficient skbs for map info"; 713 goto send_mapping_info_exit; 714 } 715 skb = dev_alloc_skb(NLMSG_GOODSIZE); 716 if (!skb) { 717 ret = -ENOMEM; 718 err_str = "Unable to allocate skb"; 719 goto send_mapping_info_exit; 720 } 721 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 722 } 723 } 724 } 725 send_mapping_info_unlock: 726 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 727 send_mapping_info_exit: 728 if (ret) { 729 pr_warn("%s: %s (ret = %d)\n", __func__, err_str, ret); 730 if (skb) 731 dev_kfree_skb(skb); 732 return ret; 733 } 734 send_nlmsg_done(skb, nl_client, iwpm_pid); 735 return send_mapinfo_num(mapping_num, nl_client, iwpm_pid); 736 } 737 738 int iwpm_mapinfo_available(void) 739 { 740 unsigned long flags; 741 int full_bucket = 0, i = 0; 742 743 spin_lock_irqsave(&iwpm_mapinfo_lock, flags); 744 if (iwpm_hash_bucket) { 745 for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) { 746 if (!hlist_empty(&iwpm_hash_bucket[i])) { 747 full_bucket = 1; 748 break; 749 } 750 } 751 } 752 spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags); 753 return full_bucket; 754 } 755