Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2005 Voltaire Inc. All rights reserved. |
| 3 | * Copyright (c) 2005 Intel Corporation. All rights reserved. |
| 4 | * |
Sean Hefty | a947491 | 2008-07-14 23:48:43 -0700 | [diff] [blame] | 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: |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 10 | * |
Sean Hefty | a947491 | 2008-07-14 23:48:43 -0700 | [diff] [blame] | 11 | * Redistribution and use in source and binary forms, with or |
| 12 | * without modification, are permitted provided that the following |
| 13 | * conditions are met: |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 14 | * |
Sean Hefty | a947491 | 2008-07-14 23:48:43 -0700 | [diff] [blame] | 15 | * - Redistributions of source code must retain the above |
| 16 | * copyright notice, this list of conditions and the following |
| 17 | * disclaimer. |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 18 | * |
Sean Hefty | a947491 | 2008-07-14 23:48:43 -0700 | [diff] [blame] | 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. |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 23 | * |
Sean Hefty | a947491 | 2008-07-14 23:48:43 -0700 | [diff] [blame] | 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. |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 32 | */ |
| 33 | |
| 34 | #if !defined(IB_ADDR_H) |
| 35 | #define IB_ADDR_H |
| 36 | |
| 37 | #include <linux/in.h> |
| 38 | #include <linux/in6.h> |
Sean Hefty | c4315d8 | 2009-11-19 12:57:18 -0800 | [diff] [blame] | 39 | #include <linux/if_arp.h> |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 40 | #include <linux/netdevice.h> |
| 41 | #include <linux/socket.h> |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 42 | #include <linux/if_vlan.h> |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 43 | #include <rdma/ib_verbs.h> |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 44 | #include <rdma/ib_pack.h> |
Matan Barak | dd5f03b | 2013-12-12 18:03:11 +0200 | [diff] [blame^] | 45 | #include <net/ipv6.h> |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 46 | |
Sean Hefty | 7a118df | 2006-10-31 11:12:59 -0800 | [diff] [blame] | 47 | struct rdma_addr_client { |
| 48 | atomic_t refcount; |
| 49 | struct completion comp; |
| 50 | }; |
| 51 | |
| 52 | /** |
| 53 | * rdma_addr_register_client - Register an address client. |
| 54 | */ |
| 55 | void rdma_addr_register_client(struct rdma_addr_client *client); |
| 56 | |
| 57 | /** |
| 58 | * rdma_addr_unregister_client - Deregister an address client. |
| 59 | * @client: Client object to deregister. |
| 60 | */ |
| 61 | void rdma_addr_unregister_client(struct rdma_addr_client *client); |
| 62 | |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 63 | struct rdma_dev_addr { |
| 64 | unsigned char src_dev_addr[MAX_ADDR_LEN]; |
| 65 | unsigned char dst_dev_addr[MAX_ADDR_LEN]; |
| 66 | unsigned char broadcast[MAX_ADDR_LEN]; |
Sean Hefty | c4315d8 | 2009-11-19 12:57:18 -0800 | [diff] [blame] | 67 | unsigned short dev_type; |
Sean Hefty | 6266ed6 | 2009-11-19 12:55:22 -0800 | [diff] [blame] | 68 | int bound_dev_if; |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 69 | enum rdma_transport_type transport; |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 70 | }; |
| 71 | |
| 72 | /** |
| 73 | * rdma_translate_ip - Translate a local IP address to an RDMA hardware |
| 74 | * address. |
| 75 | */ |
Matan Barak | dd5f03b | 2013-12-12 18:03:11 +0200 | [diff] [blame^] | 76 | int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr, |
| 77 | u16 *vlan_id); |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 78 | |
| 79 | /** |
| 80 | * rdma_resolve_ip - Resolve source and destination IP addresses to |
| 81 | * RDMA hardware addresses. |
Sean Hefty | 7a118df | 2006-10-31 11:12:59 -0800 | [diff] [blame] | 82 | * @client: Address client associated with request. |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 83 | * @src_addr: An optional source address to use in the resolution. If a |
| 84 | * source address is not provided, a usable address will be returned via |
| 85 | * the callback. |
| 86 | * @dst_addr: The destination address to resolve. |
| 87 | * @addr: A reference to a data location that will receive the resolved |
| 88 | * addresses. The data location must remain valid until the callback has |
| 89 | * been invoked. |
| 90 | * @timeout_ms: Amount of time to wait for the address resolution to complete. |
| 91 | * @callback: Call invoked once address resolution has completed, timed out, |
| 92 | * or been canceled. A status of 0 indicates success. |
| 93 | * @context: User-specified context associated with the call. |
| 94 | */ |
Sean Hefty | 7a118df | 2006-10-31 11:12:59 -0800 | [diff] [blame] | 95 | int rdma_resolve_ip(struct rdma_addr_client *client, |
| 96 | struct sockaddr *src_addr, struct sockaddr *dst_addr, |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 97 | struct rdma_dev_addr *addr, int timeout_ms, |
| 98 | void (*callback)(int status, struct sockaddr *src_addr, |
| 99 | struct rdma_dev_addr *addr, void *context), |
| 100 | void *context); |
| 101 | |
| 102 | void rdma_addr_cancel(struct rdma_dev_addr *addr); |
| 103 | |
Tom Tucker | 07ebafb | 2006-08-03 16:02:42 -0500 | [diff] [blame] | 104 | int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev, |
| 105 | const unsigned char *dst_dev_addr); |
| 106 | |
Sean Hefty | ef56086 | 2013-05-29 10:09:10 -0700 | [diff] [blame] | 107 | int rdma_addr_size(struct sockaddr *addr); |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 108 | |
Matan Barak | dd5f03b | 2013-12-12 18:03:11 +0200 | [diff] [blame^] | 109 | int rdma_addr_find_smac_by_sgid(union ib_gid *sgid, u8 *smac, u16 *vlan_id); |
| 110 | int rdma_addr_find_dmac_by_grh(union ib_gid *sgid, union ib_gid *dgid, u8 *smac, |
| 111 | u16 *vlan_id); |
| 112 | |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 113 | static inline u16 ib_addr_get_pkey(struct rdma_dev_addr *dev_addr) |
| 114 | { |
| 115 | return ((u16)dev_addr->broadcast[8] << 8) | (u16)dev_addr->broadcast[9]; |
| 116 | } |
| 117 | |
| 118 | static inline void ib_addr_set_pkey(struct rdma_dev_addr *dev_addr, u16 pkey) |
| 119 | { |
| 120 | dev_addr->broadcast[8] = pkey >> 8; |
| 121 | dev_addr->broadcast[9] = (unsigned char) pkey; |
| 122 | } |
| 123 | |
Sean Hefty | faec2f7 | 2007-02-15 17:00:17 -0800 | [diff] [blame] | 124 | static inline void ib_addr_get_mgid(struct rdma_dev_addr *dev_addr, |
| 125 | union ib_gid *gid) |
| 126 | { |
| 127 | memcpy(gid, dev_addr->broadcast + 4, sizeof *gid); |
| 128 | } |
| 129 | |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 130 | static inline int rdma_addr_gid_offset(struct rdma_dev_addr *dev_addr) |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 131 | { |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 132 | return dev_addr->dev_type == ARPHRD_INFINIBAND ? 4 : 0; |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 133 | } |
| 134 | |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 135 | static inline void iboe_mac_vlan_to_ll(union ib_gid *gid, u8 *mac, u16 vid) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 136 | { |
| 137 | memset(gid->raw, 0, 16); |
| 138 | *((__be32 *) gid->raw) = cpu_to_be32(0xfe800000); |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 139 | if (vid < 0x1000) { |
| 140 | gid->raw[12] = vid & 0xff; |
| 141 | gid->raw[11] = vid >> 8; |
| 142 | } else { |
| 143 | gid->raw[12] = 0xfe; |
| 144 | gid->raw[11] = 0xff; |
| 145 | } |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 146 | memcpy(gid->raw + 13, mac + 3, 3); |
| 147 | memcpy(gid->raw + 8, mac, 3); |
| 148 | gid->raw[8] ^= 2; |
| 149 | } |
| 150 | |
Matan Barak | dd5f03b | 2013-12-12 18:03:11 +0200 | [diff] [blame^] | 151 | static inline int rdma_ip2gid(struct sockaddr *addr, union ib_gid *gid) |
| 152 | { |
| 153 | switch (addr->sa_family) { |
| 154 | case AF_INET: |
| 155 | ipv6_addr_set_v4mapped(((struct sockaddr_in *) |
| 156 | addr)->sin_addr.s_addr, |
| 157 | (struct in6_addr *)gid); |
| 158 | break; |
| 159 | case AF_INET6: |
| 160 | memcpy(gid->raw, &((struct sockaddr_in6 *)addr)->sin6_addr, 16); |
| 161 | break; |
| 162 | default: |
| 163 | return -EINVAL; |
| 164 | } |
| 165 | return 0; |
| 166 | } |
| 167 | |
| 168 | /* Important - sockaddr should be a union of sockaddr_in and sockaddr_in6 */ |
| 169 | static inline int rdma_gid2ip(struct sockaddr *out, union ib_gid *gid) |
| 170 | { |
| 171 | if (ipv6_addr_v4mapped((struct in6_addr *)gid)) { |
| 172 | struct sockaddr_in *out_in = (struct sockaddr_in *)out; |
| 173 | memset(out_in, 0, sizeof(*out_in)); |
| 174 | out_in->sin_family = AF_INET; |
| 175 | memcpy(&out_in->sin_addr.s_addr, gid->raw + 12, 4); |
| 176 | } else { |
| 177 | struct sockaddr_in6 *out_in = (struct sockaddr_in6 *)out; |
| 178 | memset(out_in, 0, sizeof(*out_in)); |
| 179 | out_in->sin6_family = AF_INET6; |
| 180 | memcpy(&out_in->sin6_addr.s6_addr, gid->raw, 16); |
| 181 | } |
| 182 | return 0; |
| 183 | } |
| 184 | |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 185 | static inline u16 rdma_vlan_dev_vlan_id(const struct net_device *dev) |
| 186 | { |
| 187 | return dev->priv_flags & IFF_802_1Q_VLAN ? |
| 188 | vlan_dev_vlan_id(dev) : 0xffff; |
| 189 | } |
| 190 | |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 191 | static inline void iboe_addr_get_sgid(struct rdma_dev_addr *dev_addr, |
| 192 | union ib_gid *gid) |
| 193 | { |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 194 | struct net_device *dev; |
| 195 | u16 vid = 0xffff; |
| 196 | |
| 197 | dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if); |
| 198 | if (dev) { |
| 199 | vid = rdma_vlan_dev_vlan_id(dev); |
| 200 | dev_put(dev); |
| 201 | } |
| 202 | |
| 203 | iboe_mac_vlan_to_ll(gid, dev_addr->src_dev_addr, vid); |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 204 | } |
| 205 | |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 206 | static inline void rdma_addr_get_sgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid) |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 207 | { |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 208 | if (dev_addr->transport == RDMA_TRANSPORT_IB && |
| 209 | dev_addr->dev_type != ARPHRD_INFINIBAND) |
| 210 | iboe_addr_get_sgid(dev_addr, gid); |
| 211 | else |
| 212 | memcpy(gid, dev_addr->src_dev_addr + |
| 213 | rdma_addr_gid_offset(dev_addr), sizeof *gid); |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 214 | } |
| 215 | |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 216 | static inline void rdma_addr_set_sgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid) |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 217 | { |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 218 | memcpy(dev_addr->src_dev_addr + rdma_addr_gid_offset(dev_addr), gid, sizeof *gid); |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 219 | } |
| 220 | |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 221 | static inline void rdma_addr_get_dgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid) |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 222 | { |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 223 | memcpy(gid, dev_addr->dst_dev_addr + rdma_addr_gid_offset(dev_addr), sizeof *gid); |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 224 | } |
| 225 | |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 226 | static inline void rdma_addr_set_dgid(struct rdma_dev_addr *dev_addr, union ib_gid *gid) |
Tom Tucker | 07ebafb | 2006-08-03 16:02:42 -0500 | [diff] [blame] | 227 | { |
Sean Hefty | 6f8372b | 2009-11-19 13:26:06 -0800 | [diff] [blame] | 228 | memcpy(dev_addr->dst_dev_addr + rdma_addr_gid_offset(dev_addr), gid, sizeof *gid); |
Tom Tucker | 07ebafb | 2006-08-03 16:02:42 -0500 | [diff] [blame] | 229 | } |
| 230 | |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 231 | static inline enum ib_mtu iboe_get_mtu(int mtu) |
| 232 | { |
| 233 | /* |
| 234 | * reduce IB headers from effective IBoE MTU. 28 stands for |
| 235 | * atomic header which is the biggest possible header after BTH |
| 236 | */ |
| 237 | mtu = mtu - IB_GRH_BYTES - IB_BTH_BYTES - 28; |
| 238 | |
| 239 | if (mtu >= ib_mtu_enum_to_int(IB_MTU_4096)) |
| 240 | return IB_MTU_4096; |
| 241 | else if (mtu >= ib_mtu_enum_to_int(IB_MTU_2048)) |
| 242 | return IB_MTU_2048; |
| 243 | else if (mtu >= ib_mtu_enum_to_int(IB_MTU_1024)) |
| 244 | return IB_MTU_1024; |
| 245 | else if (mtu >= ib_mtu_enum_to_int(IB_MTU_512)) |
| 246 | return IB_MTU_512; |
| 247 | else if (mtu >= ib_mtu_enum_to_int(IB_MTU_256)) |
| 248 | return IB_MTU_256; |
| 249 | else |
| 250 | return 0; |
| 251 | } |
| 252 | |
| 253 | static inline int iboe_get_rate(struct net_device *dev) |
| 254 | { |
| 255 | struct ethtool_cmd cmd; |
David Decotigny | 8ae6dac | 2011-04-27 18:32:38 +0000 | [diff] [blame] | 256 | u32 speed; |
Jiri Pirko | 4bc71cb | 2011-09-03 03:34:30 +0000 | [diff] [blame] | 257 | int err; |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 258 | |
Jiri Pirko | 4bc71cb | 2011-09-03 03:34:30 +0000 | [diff] [blame] | 259 | rtnl_lock(); |
| 260 | err = __ethtool_get_settings(dev, &cmd); |
| 261 | rtnl_unlock(); |
| 262 | if (err) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 263 | return IB_RATE_PORT_CURRENT; |
| 264 | |
David Decotigny | 8ae6dac | 2011-04-27 18:32:38 +0000 | [diff] [blame] | 265 | speed = ethtool_cmd_speed(&cmd); |
| 266 | if (speed >= 40000) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 267 | return IB_RATE_40_GBPS; |
David Decotigny | 8ae6dac | 2011-04-27 18:32:38 +0000 | [diff] [blame] | 268 | else if (speed >= 30000) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 269 | return IB_RATE_30_GBPS; |
David Decotigny | 8ae6dac | 2011-04-27 18:32:38 +0000 | [diff] [blame] | 270 | else if (speed >= 20000) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 271 | return IB_RATE_20_GBPS; |
David Decotigny | 8ae6dac | 2011-04-27 18:32:38 +0000 | [diff] [blame] | 272 | else if (speed >= 10000) |
Eli Cohen | 3c86aa7 | 2010-10-13 21:26:51 +0200 | [diff] [blame] | 273 | return IB_RATE_10_GBPS; |
| 274 | else |
| 275 | return IB_RATE_PORT_CURRENT; |
| 276 | } |
| 277 | |
| 278 | static inline int rdma_link_local_addr(struct in6_addr *addr) |
| 279 | { |
| 280 | if (addr->s6_addr32[0] == htonl(0xfe800000) && |
| 281 | addr->s6_addr32[1] == 0) |
| 282 | return 1; |
| 283 | |
| 284 | return 0; |
| 285 | } |
| 286 | |
| 287 | static inline void rdma_get_ll_mac(struct in6_addr *addr, u8 *mac) |
| 288 | { |
| 289 | memcpy(mac, &addr->s6_addr[8], 3); |
| 290 | memcpy(mac + 3, &addr->s6_addr[13], 3); |
| 291 | mac[0] ^= 2; |
| 292 | } |
| 293 | |
| 294 | static inline int rdma_is_multicast_addr(struct in6_addr *addr) |
| 295 | { |
| 296 | return addr->s6_addr[0] == 0xff; |
| 297 | } |
| 298 | |
| 299 | static inline void rdma_get_mcast_mac(struct in6_addr *addr, u8 *mac) |
| 300 | { |
| 301 | int i; |
| 302 | |
| 303 | mac[0] = 0x33; |
| 304 | mac[1] = 0x33; |
| 305 | for (i = 2; i < 6; ++i) |
| 306 | mac[i] = addr->s6_addr[i + 10]; |
| 307 | } |
| 308 | |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 309 | static inline u16 rdma_get_vlan_id(union ib_gid *dgid) |
| 310 | { |
| 311 | u16 vid; |
| 312 | |
| 313 | vid = dgid->raw[11] << 8 | dgid->raw[12]; |
| 314 | return vid < 0x1000 ? vid : 0xffff; |
| 315 | } |
| 316 | |
| 317 | static inline struct net_device *rdma_vlan_dev_real_dev(const struct net_device *dev) |
| 318 | { |
| 319 | return dev->priv_flags & IFF_802_1Q_VLAN ? |
Sean Hefty | c89d1be | 2011-12-06 21:13:10 +0000 | [diff] [blame] | 320 | vlan_dev_real_dev(dev) : NULL; |
Eli Cohen | af7bd46 | 2010-08-26 17:18:59 +0300 | [diff] [blame] | 321 | } |
| 322 | |
Sean Hefty | 7025fcd | 2006-06-17 20:37:28 -0700 | [diff] [blame] | 323 | #endif /* IB_ADDR_H */ |