linux/drivers/infiniband/core/iwpm_util.c
<<
>>
Prefs
   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
  42static LIST_HEAD(iwpm_nlmsg_req_list);
  43static DEFINE_SPINLOCK(iwpm_nlmsg_req_lock);
  44
  45static struct hlist_head *iwpm_hash_bucket;
  46static DEFINE_SPINLOCK(iwpm_mapinfo_lock);
  47
  48static struct hlist_head *iwpm_reminfo_bucket;
  49static DEFINE_SPINLOCK(iwpm_reminfo_lock);
  50
  51static DEFINE_MUTEX(iwpm_admin_lock);
  52static struct iwpm_admin_data iwpm_admin;
  53
  54int 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 = kcalloc(IWPM_MAPINFO_HASH_SIZE,
  60                                           sizeof(struct hlist_head),
  61                                           GFP_KERNEL);
  62                if (!iwpm_hash_bucket) {
  63                        ret = -ENOMEM;
  64                        goto init_exit;
  65                }
  66                iwpm_reminfo_bucket = kcalloc(IWPM_REMINFO_HASH_SIZE,
  67                                              sizeof(struct hlist_head),
  68                                              GFP_KERNEL);
  69                if (!iwpm_reminfo_bucket) {
  70                        kfree(iwpm_hash_bucket);
  71                        ret = -ENOMEM;
  72                        goto init_exit;
  73                }
  74        }
  75        atomic_inc(&iwpm_admin.refcount);
  76init_exit:
  77        mutex_unlock(&iwpm_admin_lock);
  78        if (!ret) {
  79                iwpm_set_valid(nl_client, 1);
  80                iwpm_set_registration(nl_client, IWPM_REG_UNDEF);
  81                pr_debug("%s: Mapinfo and reminfo tables are created\n",
  82                                __func__);
  83        }
  84        return ret;
  85}
  86
  87static void free_hash_bucket(void);
  88static void free_reminfo_bucket(void);
  89
  90int iwpm_exit(u8 nl_client)
  91{
  92
  93        if (!iwpm_valid_client(nl_client))
  94                return -EINVAL;
  95        mutex_lock(&iwpm_admin_lock);
  96        if (atomic_read(&iwpm_admin.refcount) == 0) {
  97                mutex_unlock(&iwpm_admin_lock);
  98                pr_err("%s Incorrect usage - negative refcount\n", __func__);
  99                return -EINVAL;
 100        }
 101        if (atomic_dec_and_test(&iwpm_admin.refcount)) {
 102                free_hash_bucket();
 103                free_reminfo_bucket();
 104                pr_debug("%s: Resources are destroyed\n", __func__);
 105        }
 106        mutex_unlock(&iwpm_admin_lock);
 107        iwpm_set_valid(nl_client, 0);
 108        iwpm_set_registration(nl_client, IWPM_REG_UNDEF);
 109        return 0;
 110}
 111
 112static struct hlist_head *get_mapinfo_hash_bucket(struct sockaddr_storage *,
 113                                               struct sockaddr_storage *);
 114
 115int iwpm_create_mapinfo(struct sockaddr_storage *local_sockaddr,
 116                        struct sockaddr_storage *mapped_sockaddr,
 117                        u8 nl_client)
 118{
 119        struct hlist_head *hash_bucket_head = NULL;
 120        struct iwpm_mapping_info *map_info;
 121        unsigned long flags;
 122        int ret = -EINVAL;
 123
 124        if (!iwpm_valid_client(nl_client))
 125                return ret;
 126        map_info = kzalloc(sizeof(struct iwpm_mapping_info), GFP_KERNEL);
 127        if (!map_info)
 128                return -ENOMEM;
 129
 130        memcpy(&map_info->local_sockaddr, local_sockaddr,
 131               sizeof(struct sockaddr_storage));
 132        memcpy(&map_info->mapped_sockaddr, mapped_sockaddr,
 133               sizeof(struct sockaddr_storage));
 134        map_info->nl_client = nl_client;
 135
 136        spin_lock_irqsave(&iwpm_mapinfo_lock, flags);
 137        if (iwpm_hash_bucket) {
 138                hash_bucket_head = get_mapinfo_hash_bucket(
 139                                        &map_info->local_sockaddr,
 140                                        &map_info->mapped_sockaddr);
 141                if (hash_bucket_head) {
 142                        hlist_add_head(&map_info->hlist_node, hash_bucket_head);
 143                        ret = 0;
 144                }
 145        }
 146        spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags);
 147
 148        if (!hash_bucket_head)
 149                kfree(map_info);
 150        return ret;
 151}
 152
 153int iwpm_remove_mapinfo(struct sockaddr_storage *local_sockaddr,
 154                        struct sockaddr_storage *mapped_local_addr)
 155{
 156        struct hlist_node *tmp_hlist_node;
 157        struct hlist_head *hash_bucket_head;
 158        struct iwpm_mapping_info *map_info = NULL;
 159        unsigned long flags;
 160        int ret = -EINVAL;
 161
 162        spin_lock_irqsave(&iwpm_mapinfo_lock, flags);
 163        if (iwpm_hash_bucket) {
 164                hash_bucket_head = get_mapinfo_hash_bucket(
 165                                        local_sockaddr,
 166                                        mapped_local_addr);
 167                if (!hash_bucket_head)
 168                        goto remove_mapinfo_exit;
 169
 170                hlist_for_each_entry_safe(map_info, tmp_hlist_node,
 171                                        hash_bucket_head, hlist_node) {
 172
 173                        if (!iwpm_compare_sockaddr(&map_info->mapped_sockaddr,
 174                                                mapped_local_addr)) {
 175
 176                                hlist_del_init(&map_info->hlist_node);
 177                                kfree(map_info);
 178                                ret = 0;
 179                                break;
 180                        }
 181                }
 182        }
 183remove_mapinfo_exit:
 184        spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags);
 185        return ret;
 186}
 187
 188static void free_hash_bucket(void)
 189{
 190        struct hlist_node *tmp_hlist_node;
 191        struct iwpm_mapping_info *map_info;
 192        unsigned long flags;
 193        int i;
 194
 195        /* remove all the mapinfo data from the list */
 196        spin_lock_irqsave(&iwpm_mapinfo_lock, flags);
 197        for (i = 0; i < IWPM_MAPINFO_HASH_SIZE; i++) {
 198                hlist_for_each_entry_safe(map_info, tmp_hlist_node,
 199                        &iwpm_hash_bucket[i], hlist_node) {
 200
 201                                hlist_del_init(&map_info->hlist_node);
 202                                kfree(map_info);
 203                        }
 204        }
 205        /* free the hash list */
 206        kfree(iwpm_hash_bucket);
 207        iwpm_hash_bucket = NULL;
 208        spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags);
 209}
 210
 211static void free_reminfo_bucket(void)
 212{
 213        struct hlist_node *tmp_hlist_node;
 214        struct iwpm_remote_info *rem_info;
 215        unsigned long flags;
 216        int i;
 217
 218        /* remove all the remote info from the list */
 219        spin_lock_irqsave(&iwpm_reminfo_lock, flags);
 220        for (i = 0; i < IWPM_REMINFO_HASH_SIZE; i++) {
 221                hlist_for_each_entry_safe(rem_info, tmp_hlist_node,
 222                        &iwpm_reminfo_bucket[i], hlist_node) {
 223
 224                                hlist_del_init(&rem_info->hlist_node);
 225                                kfree(rem_info);
 226                        }
 227        }
 228        /* free the hash list */
 229        kfree(iwpm_reminfo_bucket);
 230        iwpm_reminfo_bucket = NULL;
 231        spin_unlock_irqrestore(&iwpm_reminfo_lock, flags);
 232}
 233
 234static struct hlist_head *get_reminfo_hash_bucket(struct sockaddr_storage *,
 235                                                struct sockaddr_storage *);
 236
 237void iwpm_add_remote_info(struct iwpm_remote_info *rem_info)
 238{
 239        struct hlist_head *hash_bucket_head;
 240        unsigned long flags;
 241
 242        spin_lock_irqsave(&iwpm_reminfo_lock, flags);
 243        if (iwpm_reminfo_bucket) {
 244                hash_bucket_head = get_reminfo_hash_bucket(
 245                                        &rem_info->mapped_loc_sockaddr,
 246                                        &rem_info->mapped_rem_sockaddr);
 247                if (hash_bucket_head)
 248                        hlist_add_head(&rem_info->hlist_node, hash_bucket_head);
 249        }
 250        spin_unlock_irqrestore(&iwpm_reminfo_lock, flags);
 251}
 252
 253int iwpm_get_remote_info(struct sockaddr_storage *mapped_loc_addr,
 254                         struct sockaddr_storage *mapped_rem_addr,
 255                         struct sockaddr_storage *remote_addr,
 256                         u8 nl_client)
 257{
 258        struct hlist_node *tmp_hlist_node;
 259        struct hlist_head *hash_bucket_head;
 260        struct iwpm_remote_info *rem_info = NULL;
 261        unsigned long flags;
 262        int ret = -EINVAL;
 263
 264        if (!iwpm_valid_client(nl_client)) {
 265                pr_info("%s: Invalid client = %d\n", __func__, nl_client);
 266                return ret;
 267        }
 268        spin_lock_irqsave(&iwpm_reminfo_lock, flags);
 269        if (iwpm_reminfo_bucket) {
 270                hash_bucket_head = get_reminfo_hash_bucket(
 271                                        mapped_loc_addr,
 272                                        mapped_rem_addr);
 273                if (!hash_bucket_head)
 274                        goto get_remote_info_exit;
 275                hlist_for_each_entry_safe(rem_info, tmp_hlist_node,
 276                                        hash_bucket_head, hlist_node) {
 277
 278                        if (!iwpm_compare_sockaddr(&rem_info->mapped_loc_sockaddr,
 279                                mapped_loc_addr) &&
 280                                !iwpm_compare_sockaddr(&rem_info->mapped_rem_sockaddr,
 281                                mapped_rem_addr)) {
 282
 283                                memcpy(remote_addr, &rem_info->remote_sockaddr,
 284                                        sizeof(struct sockaddr_storage));
 285                                iwpm_print_sockaddr(remote_addr,
 286                                                "get_remote_info: Remote sockaddr:");
 287
 288                                hlist_del_init(&rem_info->hlist_node);
 289                                kfree(rem_info);
 290                                ret = 0;
 291                                break;
 292                        }
 293                }
 294        }
 295get_remote_info_exit:
 296        spin_unlock_irqrestore(&iwpm_reminfo_lock, flags);
 297        return ret;
 298}
 299
 300struct iwpm_nlmsg_request *iwpm_get_nlmsg_request(__u32 nlmsg_seq,
 301                                        u8 nl_client, gfp_t gfp)
 302{
 303        struct iwpm_nlmsg_request *nlmsg_request = NULL;
 304        unsigned long flags;
 305
 306        nlmsg_request = kzalloc(sizeof(struct iwpm_nlmsg_request), gfp);
 307        if (!nlmsg_request)
 308                return NULL;
 309
 310        spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags);
 311        list_add_tail(&nlmsg_request->inprocess_list, &iwpm_nlmsg_req_list);
 312        spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags);
 313
 314        kref_init(&nlmsg_request->kref);
 315        kref_get(&nlmsg_request->kref);
 316        nlmsg_request->nlmsg_seq = nlmsg_seq;
 317        nlmsg_request->nl_client = nl_client;
 318        nlmsg_request->request_done = 0;
 319        nlmsg_request->err_code = 0;
 320        sema_init(&nlmsg_request->sem, 1);
 321        down(&nlmsg_request->sem);
 322        return nlmsg_request;
 323}
 324
 325void iwpm_free_nlmsg_request(struct kref *kref)
 326{
 327        struct iwpm_nlmsg_request *nlmsg_request;
 328        unsigned long flags;
 329
 330        nlmsg_request = container_of(kref, struct iwpm_nlmsg_request, kref);
 331
 332        spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags);
 333        list_del_init(&nlmsg_request->inprocess_list);
 334        spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags);
 335
 336        if (!nlmsg_request->request_done)
 337                pr_debug("%s Freeing incomplete nlmsg request (seq = %u).\n",
 338                        __func__, nlmsg_request->nlmsg_seq);
 339        kfree(nlmsg_request);
 340}
 341
 342struct iwpm_nlmsg_request *iwpm_find_nlmsg_request(__u32 echo_seq)
 343{
 344        struct iwpm_nlmsg_request *nlmsg_request;
 345        struct iwpm_nlmsg_request *found_request = NULL;
 346        unsigned long flags;
 347
 348        spin_lock_irqsave(&iwpm_nlmsg_req_lock, flags);
 349        list_for_each_entry(nlmsg_request, &iwpm_nlmsg_req_list,
 350                            inprocess_list) {
 351                if (nlmsg_request->nlmsg_seq == echo_seq) {
 352                        found_request = nlmsg_request;
 353                        kref_get(&nlmsg_request->kref);
 354                        break;
 355                }
 356        }
 357        spin_unlock_irqrestore(&iwpm_nlmsg_req_lock, flags);
 358        return found_request;
 359}
 360
 361int iwpm_wait_complete_req(struct iwpm_nlmsg_request *nlmsg_request)
 362{
 363        int ret;
 364
 365        ret = down_timeout(&nlmsg_request->sem, IWPM_NL_TIMEOUT);
 366        if (ret) {
 367                ret = -EINVAL;
 368                pr_info("%s: Timeout %d sec for netlink request (seq = %u)\n",
 369                        __func__, (IWPM_NL_TIMEOUT/HZ), nlmsg_request->nlmsg_seq);
 370        } else {
 371                ret = nlmsg_request->err_code;
 372        }
 373        kref_put(&nlmsg_request->kref, iwpm_free_nlmsg_request);
 374        return ret;
 375}
 376
 377int iwpm_get_nlmsg_seq(void)
 378{
 379        return atomic_inc_return(&iwpm_admin.nlmsg_seq);
 380}
 381
 382int iwpm_valid_client(u8 nl_client)
 383{
 384        return iwpm_admin.client_list[nl_client];
 385}
 386
 387void iwpm_set_valid(u8 nl_client, int valid)
 388{
 389        iwpm_admin.client_list[nl_client] = valid;
 390}
 391
 392/* valid client */
 393u32 iwpm_get_registration(u8 nl_client)
 394{
 395        return iwpm_admin.reg_list[nl_client];
 396}
 397
 398/* valid client */
 399void iwpm_set_registration(u8 nl_client, u32 reg)
 400{
 401        iwpm_admin.reg_list[nl_client] = reg;
 402}
 403
 404/* valid client */
 405u32 iwpm_check_registration(u8 nl_client, u32 reg)
 406{
 407        return (iwpm_get_registration(nl_client) & reg);
 408}
 409
 410int iwpm_compare_sockaddr(struct sockaddr_storage *a_sockaddr,
 411                                struct sockaddr_storage *b_sockaddr)
 412{
 413        if (a_sockaddr->ss_family != b_sockaddr->ss_family)
 414                return 1;
 415        if (a_sockaddr->ss_family == AF_INET) {
 416                struct sockaddr_in *a4_sockaddr =
 417                        (struct sockaddr_in *)a_sockaddr;
 418                struct sockaddr_in *b4_sockaddr =
 419                        (struct sockaddr_in *)b_sockaddr;
 420                if (!memcmp(&a4_sockaddr->sin_addr,
 421                        &b4_sockaddr->sin_addr, sizeof(struct in_addr))
 422                        && a4_sockaddr->sin_port == b4_sockaddr->sin_port)
 423                                return 0;
 424
 425        } else if (a_sockaddr->ss_family == AF_INET6) {
 426                struct sockaddr_in6 *a6_sockaddr =
 427                        (struct sockaddr_in6 *)a_sockaddr;
 428                struct sockaddr_in6 *b6_sockaddr =
 429                        (struct sockaddr_in6 *)b_sockaddr;
 430                if (!memcmp(&a6_sockaddr->sin6_addr,
 431                        &b6_sockaddr->sin6_addr, sizeof(struct in6_addr))
 432                        && a6_sockaddr->sin6_port == b6_sockaddr->sin6_port)
 433                                return 0;
 434
 435        } else {
 436                pr_err("%s: Invalid sockaddr family\n", __func__);
 437        }
 438        return 1;
 439}
 440
 441struct sk_buff *iwpm_create_nlmsg(u32 nl_op, struct nlmsghdr **nlh,
 442                                                int nl_client)
 443{
 444        struct sk_buff *skb = NULL;
 445
 446        skb = dev_alloc_skb(IWPM_MSG_SIZE);
 447        if (!skb)
 448                goto create_nlmsg_exit;
 449
 450        if (!(ibnl_put_msg(skb, nlh, 0, 0, nl_client, nl_op,
 451                           NLM_F_REQUEST))) {
 452                pr_warn("%s: Unable to put the nlmsg header\n", __func__);
 453                dev_kfree_skb(skb);
 454                skb = NULL;
 455        }
 456create_nlmsg_exit:
 457        return skb;
 458}
 459
 460int iwpm_parse_nlmsg(struct netlink_callback *cb, int policy_max,
 461                                   const struct nla_policy *nlmsg_policy,
 462                                   struct nlattr *nltb[], const char *msg_type)
 463{
 464        int nlh_len = 0;
 465        int ret;
 466        const char *err_str = "";
 467
 468        ret = nlmsg_validate(cb->nlh, nlh_len, policy_max-1, nlmsg_policy);
 469        if (ret) {
 470                err_str = "Invalid attribute";
 471                goto parse_nlmsg_error;
 472        }
 473        ret = nlmsg_parse(cb->nlh, nlh_len, nltb, policy_max-1, nlmsg_policy);
 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;
 484parse_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
 490void 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
 515static 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
 522static 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
 529static 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
 553static 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
 566static 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
 579static 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;
 613mapinfo_num_error:
 614        pr_info("%s: %s\n", __func__, err_str);
 615        if (skb)
 616                dev_kfree_skb(skb);
 617        return ret;
 618}
 619
 620static 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
 640int 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        }
 725send_mapping_info_unlock:
 726        spin_unlock_irqrestore(&iwpm_mapinfo_lock, flags);
 727send_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
 738int 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