linux/drivers/infiniband/hw/usnic/usnic_transport.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2013, Cisco Systems, Inc. All rights reserved.
   3 *
   4 * This software is available to you under a choice of one of two
   5 * licenses.  You may choose to be licensed under the terms of the GNU
   6 * General Public License (GPL) Version 2, available from the file
   7 * COPYING in the main directory of this source tree, or the
   8 * BSD license below:
   9 *
  10 *     Redistribution and use in source and binary forms, with or
  11 *     without modification, are permitted provided that the following
  12 *     conditions are met:
  13 *
  14 *      - Redistributions of source code must retain the above
  15 *        copyright notice, this list of conditions and the following
  16 *        disclaimer.
  17 *
  18 *      - Redistributions in binary form must reproduce the above
  19 *        copyright notice, this list of conditions and the following
  20 *        disclaimer in the documentation and/or other materials
  21 *        provided with the distribution.
  22 *
  23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  30 * SOFTWARE.
  31 *
  32 */
  33#include <linux/bitmap.h>
  34#include <linux/file.h>
  35#include <linux/module.h>
  36#include <linux/slab.h>
  37#include <net/inet_sock.h>
  38
  39#include "usnic_transport.h"
  40#include "usnic_log.h"
  41
  42/* ROCE */
  43static unsigned long *roce_bitmap;
  44static u16 roce_next_port = 1;
  45#define ROCE_BITMAP_SZ ((1 << (8 /*CHAR_BIT*/ * sizeof(u16)))/8 /*CHAR BIT*/)
  46static DEFINE_SPINLOCK(roce_bitmap_lock);
  47
  48const char *usnic_transport_to_str(enum usnic_transport_type type)
  49{
  50        switch (type) {
  51        case USNIC_TRANSPORT_UNKNOWN:
  52                return "Unknown";
  53        case USNIC_TRANSPORT_ROCE_CUSTOM:
  54                return "roce custom";
  55        case USNIC_TRANSPORT_IPV4_UDP:
  56                return "IPv4 UDP";
  57        case USNIC_TRANSPORT_MAX:
  58                return "Max?";
  59        default:
  60                return "Not known";
  61        }
  62}
  63
  64int usnic_transport_sock_to_str(char *buf, int buf_sz,
  65                                        struct socket *sock)
  66{
  67        int err;
  68        uint32_t addr;
  69        uint16_t port;
  70        int proto;
  71
  72        memset(buf, 0, buf_sz);
  73        err = usnic_transport_sock_get_addr(sock, &proto, &addr, &port);
  74        if (err)
  75                return 0;
  76
  77        return scnprintf(buf, buf_sz, "Proto:%u Addr:%pI4h Port:%hu",
  78                        proto, &addr, port);
  79}
  80
  81/*
  82 * reserve a port number.  if "0" specified, we will try to pick one
  83 * starting at roce_next_port.  roce_next_port will take on the values
  84 * 1..4096
  85 */
  86u16 usnic_transport_rsrv_port(enum usnic_transport_type type, u16 port_num)
  87{
  88        if (type == USNIC_TRANSPORT_ROCE_CUSTOM) {
  89                spin_lock(&roce_bitmap_lock);
  90                if (!port_num) {
  91                        port_num = bitmap_find_next_zero_area(roce_bitmap,
  92                                                ROCE_BITMAP_SZ,
  93                                                roce_next_port /* start */,
  94                                                1 /* nr */,
  95                                                0 /* align */);
  96                        roce_next_port = (port_num & 4095) + 1;
  97                } else if (test_bit(port_num, roce_bitmap)) {
  98                        usnic_err("Failed to allocate port for %s\n",
  99                                        usnic_transport_to_str(type));
 100                        spin_unlock(&roce_bitmap_lock);
 101                        goto out_fail;
 102                }
 103                bitmap_set(roce_bitmap, port_num, 1);
 104                spin_unlock(&roce_bitmap_lock);
 105        } else {
 106                usnic_err("Failed to allocate port - transport %s unsupported\n",
 107                                usnic_transport_to_str(type));
 108                goto out_fail;
 109        }
 110
 111        usnic_dbg("Allocating port %hu for %s\n", port_num,
 112                        usnic_transport_to_str(type));
 113        return port_num;
 114
 115out_fail:
 116        return 0;
 117}
 118
 119void usnic_transport_unrsrv_port(enum usnic_transport_type type, u16 port_num)
 120{
 121        if (type == USNIC_TRANSPORT_ROCE_CUSTOM) {
 122                spin_lock(&roce_bitmap_lock);
 123                if (!port_num) {
 124                        usnic_err("Unreserved invalid port num 0 for %s\n",
 125                                        usnic_transport_to_str(type));
 126                        goto out_roce_custom;
 127                }
 128
 129                if (!test_bit(port_num, roce_bitmap)) {
 130                        usnic_err("Unreserving invalid %hu for %s\n",
 131                                        port_num,
 132                                        usnic_transport_to_str(type));
 133                        goto out_roce_custom;
 134                }
 135                bitmap_clear(roce_bitmap, port_num, 1);
 136                usnic_dbg("Freeing port %hu for %s\n", port_num,
 137                                usnic_transport_to_str(type));
 138out_roce_custom:
 139                spin_unlock(&roce_bitmap_lock);
 140        } else {
 141                usnic_err("Freeing invalid port %hu for %d\n", port_num, type);
 142        }
 143}
 144
 145struct socket *usnic_transport_get_socket(int sock_fd)
 146{
 147        struct socket *sock;
 148        int err;
 149        char buf[25];
 150
 151        /* sockfd_lookup will internally do a fget */
 152        sock = sockfd_lookup(sock_fd, &err);
 153        if (!sock) {
 154                usnic_err("Unable to lookup socket for fd %d with err %d\n",
 155                                sock_fd, err);
 156                return ERR_PTR(-ENOENT);
 157        }
 158
 159        usnic_transport_sock_to_str(buf, sizeof(buf), sock);
 160        usnic_dbg("Get sock %s\n", buf);
 161
 162        return sock;
 163}
 164
 165void usnic_transport_put_socket(struct socket *sock)
 166{
 167        char buf[100];
 168
 169        usnic_transport_sock_to_str(buf, sizeof(buf), sock);
 170        usnic_dbg("Put sock %s\n", buf);
 171        sockfd_put(sock);
 172}
 173
 174int usnic_transport_sock_get_addr(struct socket *sock, int *proto,
 175                                        uint32_t *addr, uint16_t *port)
 176{
 177        int err;
 178        struct sockaddr_in sock_addr;
 179
 180        err = sock->ops->getname(sock,
 181                                (struct sockaddr *)&sock_addr,
 182                                0);
 183        if (err < 0)
 184                return err;
 185
 186        if (sock_addr.sin_family != AF_INET)
 187                return -EINVAL;
 188
 189        if (proto)
 190                *proto = sock->sk->sk_protocol;
 191        if (port)
 192                *port = ntohs(((struct sockaddr_in *)&sock_addr)->sin_port);
 193        if (addr)
 194                *addr = ntohl(((struct sockaddr_in *)
 195                                        &sock_addr)->sin_addr.s_addr);
 196
 197        return 0;
 198}
 199
 200int usnic_transport_init(void)
 201{
 202        roce_bitmap = kzalloc(ROCE_BITMAP_SZ, GFP_KERNEL);
 203        if (!roce_bitmap)
 204                return -ENOMEM;
 205
 206        /* Do not ever allocate bit 0, hence set it here */
 207        bitmap_set(roce_bitmap, 0, 1);
 208        return 0;
 209}
 210
 211void usnic_transport_fini(void)
 212{
 213        kfree(roce_bitmap);
 214}
 215