drivers/infiniband/core/iwpm_util.c

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