include/rdma/ib_addr.h

   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  */
  62 struct 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  */
  80 int 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  */
  98 int 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
 104 void rdma_addr_cancel(struct rdma_dev_addr *addr);
 105
 106 void rdma_copy_addr(struct rdma_dev_addr *dev_addr,
 107                     const struct net_device *dev,
 108                     const unsigned char *dst_dev_addr);
 109
 110 int rdma_addr_size(struct sockaddr *addr);
 111 int rdma_addr_size_in6(struct sockaddr_in6 *addr);
 112 int rdma_addr_size_kss(struct __kernel_sockaddr_storage *addr);
 113
 114 static 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
 119 static 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
 125 static 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
 131 static 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
 136 static 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
 141 static 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 */
 160 static 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  */
 180 static 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
 186 static 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
 191 static 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
 196 static 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
 201 static 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
 224 static 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
 247 static 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
 256 static 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
 263 static 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
 274 static 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
 284 static 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
 292 static 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 */