LXR linux/include/rdma/ib

   1/*
   2 * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
   3 * Copyright (c) 2005 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#if !defined(IB_ADDR_H)
  35#define IB_ADDR_H
  36
  37#include <linux/in.h>
  38#include <linux/in6.h>
  39#include <linux/if_arp.h>
  40#include <linux/netdevice.h>
  41#include <linux/inetdevice.h>
  42#include <linux/socket.h>
  43#include <linux/if_vlan.h>
  44#include <net/ipv6.h>
  45#include <net/if_inet6.h>
  46#include <net/ip.h>
  47#include <rdma/ib_verbs.h>
  48#include <rdma/ib_pack.h>
  49#include <net/ipv6.h>
  50#include <net/net_namespace.h>
  51
  52/**
  53 * struct rdma_dev_addr - Contains resolved RDMA hardware addresses
  54 * @src_dev_addr:       Source MAC address.
  55 * @dst_dev_addr:       Destination MAC address.
  56 * @broadcast:          Broadcast address of the device.
  57 * @dev_type:           The interface hardware type of the device.
  58 * @bound_dev_if:       An optional device interface index.
  59 * @transport:          The transport type used.
  60 * @net:                Network namespace containing the bound_dev_if net_dev.
  61 */
  62struct rdma_dev_addr {
  63        unsigned char src_dev_addr[MAX_ADDR_LEN];
  64        unsigned char dst_dev_addr[MAX_ADDR_LEN];
  65        unsigned char broadcast[MAX_ADDR_LEN];
  66        unsigned short dev_type;
  67        int bound_dev_if;
  68        enum rdma_transport_type transport;
  69        struct net *net;
  70        enum rdma_network_type network;
  71        int hoplimit;
  72};
  73
  74/**
  75 * rdma_translate_ip - Translate a local IP address to an RDMA hardware
  76 *   address.
  77 *
  78 * The dev_addr->net field must be initialized.
  79 */
  80int rdma_translate_ip(const struct sockaddr *addr,
  81                      struct rdma_dev_addr *dev_addr);
  82
  83/**
  84 * rdma_resolve_ip - Resolve source and destination IP addresses to
  85 *   RDMA hardware addresses.
  86 * @src_addr: An optional source address to use in the resolution.  If a
  87 *   source address is not provided, a usable address will be returned via
  88 *   the callback.
  89 * @dst_addr: The destination address to resolve.
  90 * @addr: A reference to a data location that will receive the resolved
  91 *   addresses.  The data location must remain valid until the callback has
  92 *   been invoked. The net field of the addr struct must be valid.
  93 * @timeout_ms: Amount of time to wait for the address resolution to complete.
  94 * @callback: Call invoked once address resolution has completed, timed out,
  95 *   or been canceled.  A status of 0 indicates success.
  96 * @context: User-specified context associated with the call.
  97 */
  98int rdma_resolve_ip(struct sockaddr *src_addr, struct sockaddr *dst_addr,
  99                    struct rdma_dev_addr *addr, int timeout_ms,
 100                    void (*callback)(int status, struct sockaddr *src_addr,
 101                                     struct rdma_dev_addr *addr, void *context),
 102                    void *context);
 103
 104void rdma_addr_cancel(struct rdma_dev_addr *addr);
 105
 106void rdma_copy_addr(struct rdma_dev_addr *dev_addr,
 107                    const struct net_device *dev,
 108                    const unsigned char *dst_dev_addr);
 109
 110int rdma_addr_size(struct sockaddr *addr);
 111int rdma_addr_size_in6(struct sockaddr_in6 *addr);
 112int rdma_addr_size_kss(struct __kernel_sockaddr_storage *addr);
 113
 114static inline u16 ib_addr_get_pkey(struct rdma_dev_addr *dev_addr)
 115{
 116        return ((u16)dev_addr->broadcast[8] << 8) | (u16)dev_addr->broadcast[9];
 117}
 118
 119static inline void ib_addr_set_pkey(struct rdma_dev_addr *dev_addr, u16 pkey)
 120{
 121        dev_addr->broadcast[8] = pkey >> 8;
 122        dev_addr->broadcast[9] = (unsigned char) pkey;
 123}
 124
 125static inline void ib_addr_get_mgid(struct rdma_dev_addr *dev_addr,
 126                                    union ib_gid *gid)
 127{
 128        memcpy(gid, dev_addr->broadcast + 4, sizeof *gid);
 129}
 130
 131static inline int rdma_addr_gid_offset(struct rdma_dev_addr *dev_addr)
 132{
 133        return dev_addr->dev_type == ARPHRD_INFINIBAND ? 4 : 0;
 134}
 135
 136static inline u16 rdma_vlan_dev_vlan_id(const struct net_device *dev)
 137{
 138        return is_vlan_dev(dev) ? vlan_dev_vlan_id(dev) : 0xffff;
 139}
 140
 141static inline int rdma_ip2gid(struct sockaddr *addr, union ib_gid *gid)
 142{
 143        switch (addr->sa_family) {
 144        case AF_INET:
 145                ipv6_addr_set_v4mapped(((struct sockaddr_in *)
 146                                        addr)->sin_addr.s_addr,
 147                                       (struct in6_addr *)gid);
 148                break;
 149        case AF_INET6:
 150                *(struct in6_addr *)&gid->raw =
 151                        ((struct sockaddr_in6 *)addr)->sin6_addr;
 152                break;
 153        default:
 154                return -EINVAL;
 155        }
 156        return 0;
 157}
 158
 159/* Important - sockaddr should be a union of sockaddr_in and sockaddr_in6 */
 160static inline void rdma_gid2ip(struct sockaddr *out, const union ib_gid *gid)
 161{
 162        if (ipv6_addr_v4mapped((struct in6_addr *)gid)) {
 163                struct sockaddr_in *out_in = (struct sockaddr_in *)out;
 164                memset(out_in, 0, sizeof(*out_in));
 165                out_in->sin_family = AF_INET;
 166                memcpy(&out_in->sin_addr.s_addr, gid->raw + 12, 4);
 167        } else {
 168                struct sockaddr_in6 *out_in = (struct sockaddr_in6 *)out;
 169                memset(out_in, 0, sizeof(*out_in));
 170                out_in->sin6_family = AF_INET6;
 171                memcpy(&out_in->sin6_addr.s6_addr, gid->raw, 16);
 172        }
 173}
 174
 175/*
 176 * rdma_get/set_sgid/dgid() APIs are applicable to IB, and iWarp.
 177 * They are not applicable to RoCE.
 178 * RoCE GIDs are derived from the IP addresses.
 179 */
 180static inline void rdma_addr_get_sgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid)
 181{
 182        memcpy(gid, dev_addr->src_dev_addr + rdma_addr_gid_offset(dev_addr),
 183               sizeof(*gid));
 184}
 185
 186static inline void rdma_addr_set_sgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid)
 187{
 188        memcpy(dev_addr->src_dev_addr + rdma_addr_gid_offset(dev_addr), gid, sizeof *gid);
 189}
 190
 191static inline void rdma_addr_get_dgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid)
 192{
 193        memcpy(gid, dev_addr->dst_dev_addr + rdma_addr_gid_offset(dev_addr), sizeof *gid);
 194}
 195
 196static inline void rdma_addr_set_dgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid)
 197{
 198        memcpy(dev_addr->dst_dev_addr + rdma_addr_gid_offset(dev_addr), gid, sizeof *gid);
 199}
 200
 201static inline enum ib_mtu iboe_get_mtu(int mtu)
 202{
 203        /*
 204         * Reduce IB headers from effective IBoE MTU.
 205         */
 206        mtu = mtu - (IB_GRH_BYTES + IB_UDP_BYTES + IB_BTH_BYTES +
 207                     IB_EXT_XRC_BYTES + IB_EXT_ATOMICETH_BYTES +
 208                     IB_ICRC_BYTES);
 209
 210        if (mtu >= ib_mtu_enum_to_int(IB_MTU_4096))
 211                return IB_MTU_4096;
 212        else if (mtu >= ib_mtu_enum_to_int(IB_MTU_2048))
 213                return IB_MTU_2048;
 214        else if (mtu >= ib_mtu_enum_to_int(IB_MTU_1024))
 215                return IB_MTU_1024;
 216        else if (mtu >= ib_mtu_enum_to_int(IB_MTU_512))
 217                return IB_MTU_512;
 218        else if (mtu >= ib_mtu_enum_to_int(IB_MTU_256))
 219                return IB_MTU_256;
 220        else
 221                return 0;
 222}
 223
 224static inline int iboe_get_rate(struct net_device *dev)
 225{
 226        struct ethtool_link_ksettings cmd;
 227        int err;
 228
 229        rtnl_lock();
 230        err = __ethtool_get_link_ksettings(dev, &cmd);
 231        rtnl_unlock();
 232        if (err)
 233                return IB_RATE_PORT_CURRENT;
 234
 235        if (cmd.base.speed >= 40000)
 236                return IB_RATE_40_GBPS;
 237        else if (cmd.base.speed >= 30000)
 238                return IB_RATE_30_GBPS;
 239        else if (cmd.base.speed >= 20000)
 240                return IB_RATE_20_GBPS;
 241        else if (cmd.base.speed >= 10000)
 242                return IB_RATE_10_GBPS;
 243        else
 244                return IB_RATE_PORT_CURRENT;
 245}
 246
 247static inline int rdma_link_local_addr(struct in6_addr *addr)
 248{
 249        if (addr->s6_addr32[0] == htonl(0xfe800000) &&
 250            addr->s6_addr32[1] == 0)
 251                return 1;
 252
 253        return 0;
 254}
 255
 256static inline void rdma_get_ll_mac(struct in6_addr *addr, u8 *mac)
 257{
 258        memcpy(mac, &addr->s6_addr[8], 3);
 259        memcpy(mac + 3, &addr->s6_addr[13], 3);
 260        mac[0] ^= 2;
 261}
 262
 263static inline int rdma_is_multicast_addr(struct in6_addr *addr)
 264{
 265        __be32 ipv4_addr;
 266
 267        if (addr->s6_addr[0] == 0xff)
 268                return 1;
 269
 270        ipv4_addr = addr->s6_addr32[3];
 271        return (ipv6_addr_v4mapped(addr) && ipv4_is_multicast(ipv4_addr));
 272}
 273
 274static inline void rdma_get_mcast_mac(struct in6_addr *addr, u8 *mac)
 275{
 276        int i;
 277
 278        mac[0] = 0x33;
 279        mac[1] = 0x33;
 280        for (i = 2; i < 6; ++i)
 281                mac[i] = addr->s6_addr[i + 10];
 282}
 283
 284static inline u16 rdma_get_vlan_id(union ib_gid *dgid)
 285{
 286        u16 vid;
 287
 288        vid = dgid->raw[11] << 8 | dgid->raw[12];
 289        return vid < 0x1000 ? vid : 0xffff;
 290}
 291
 292static inline struct net_device *rdma_vlan_dev_real_dev(const struct net_device *dev)
 293{
 294        return is_vlan_dev(dev) ? vlan_dev_real_dev(dev) : NULL;
 295}
 296
 297#endif /* IB_ADDR_H */
 298