1 /* 2 * This file is part of the Chelsio T4 Ethernet driver for Linux. 3 * Copyright (C) 2003-2014 Chelsio Communications. All rights reserved. 4 * 5 * Written by Deepak (deepak.s@chelsio.com) 6 * 7 * This program is distributed in the hope that it will be useful, but WITHOUT 8 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 9 * FITNESS FOR A PARTICULAR PURPOSE. See the LICENSE file included in this 10 * release for licensing terms and conditions. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/netdevice.h> 15 #include <linux/jhash.h> 16 #include <linux/if_vlan.h> 17 #include <net/addrconf.h> 18 #include "cxgb4.h" 19 #include "clip_tbl.h" 20 21 static inline unsigned int ipv4_clip_hash(struct clip_tbl *c, const u32 *key) 22 { 23 unsigned int clipt_size_half = c->clipt_size / 2; 24 25 return jhash_1word(*key, 0) % clipt_size_half; 26 } 27 28 static inline unsigned int ipv6_clip_hash(struct clip_tbl *d, const u32 *key) 29 { 30 unsigned int clipt_size_half = d->clipt_size / 2; 31 u32 xor = key[0] ^ key[1] ^ key[2] ^ key[3]; 32 33 return clipt_size_half + 34 (jhash_1word(xor, 0) % clipt_size_half); 35 } 36 37 static unsigned int clip_addr_hash(struct clip_tbl *ctbl, const u32 *addr, 38 u8 v6) 39 { 40 return v6 ? ipv6_clip_hash(ctbl, addr) : 41 ipv4_clip_hash(ctbl, addr); 42 } 43 44 static int clip6_get_mbox(const struct net_device *dev, 45 const struct in6_addr *lip) 46 { 47 struct adapter *adap = netdev2adap(dev); 48 struct fw_clip_cmd c; 49 50 memset(&c, 0, sizeof(c)); 51 c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) | 52 FW_CMD_REQUEST_F | FW_CMD_WRITE_F); 53 c.alloc_to_len16 = htonl(FW_CLIP_CMD_ALLOC_F | FW_LEN16(c)); 54 *(__be64 *)&c.ip_hi = *(__be64 *)(lip->s6_addr); 55 *(__be64 *)&c.ip_lo = *(__be64 *)(lip->s6_addr + 8); 56 return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false); 57 } 58 59 static int clip6_release_mbox(const struct net_device *dev, 60 const struct in6_addr *lip) 61 { 62 struct adapter *adap = netdev2adap(dev); 63 struct fw_clip_cmd c; 64 65 memset(&c, 0, sizeof(c)); 66 c.op_to_write = htonl(FW_CMD_OP_V(FW_CLIP_CMD) | 67 FW_CMD_REQUEST_F | FW_CMD_READ_F); 68 c.alloc_to_len16 = htonl(FW_CLIP_CMD_FREE_F | FW_LEN16(c)); 69 *(__be64 *)&c.ip_hi = *(__be64 *)(lip->s6_addr); 70 *(__be64 *)&c.ip_lo = *(__be64 *)(lip->s6_addr + 8); 71 return t4_wr_mbox_meat(adap, adap->mbox, &c, sizeof(c), &c, false); 72 } 73 74 int cxgb4_clip_get(const struct net_device *dev, const u32 *lip, u8 v6) 75 { 76 struct adapter *adap = netdev2adap(dev); 77 struct clip_tbl *ctbl = adap->clipt; 78 struct clip_entry *ce, *cte; 79 u32 *addr = (u32 *)lip; 80 int hash; 81 int ret = -1; 82 83 if (!ctbl) 84 return 0; 85 86 hash = clip_addr_hash(ctbl, addr, v6); 87 88 read_lock_bh(&ctbl->lock); 89 list_for_each_entry(cte, &ctbl->hash_list[hash], list) { 90 if (cte->addr6.sin6_family == AF_INET6 && v6) 91 ret = memcmp(lip, cte->addr6.sin6_addr.s6_addr, 92 sizeof(struct in6_addr)); 93 else if (cte->addr.sin_family == AF_INET && !v6) 94 ret = memcmp(lip, (char *)(&cte->addr.sin_addr), 95 sizeof(struct in_addr)); 96 if (!ret) { 97 ce = cte; 98 read_unlock_bh(&ctbl->lock); 99 goto found; 100 } 101 } 102 read_unlock_bh(&ctbl->lock); 103 104 write_lock_bh(&ctbl->lock); 105 if (!list_empty(&ctbl->ce_free_head)) { 106 ce = list_first_entry(&ctbl->ce_free_head, 107 struct clip_entry, list); 108 list_del(&ce->list); 109 INIT_LIST_HEAD(&ce->list); 110 spin_lock_init(&ce->lock); 111 atomic_set(&ce->refcnt, 0); 112 atomic_dec(&ctbl->nfree); 113 list_add_tail(&ce->list, &ctbl->hash_list[hash]); 114 if (v6) { 115 ce->addr6.sin6_family = AF_INET6; 116 memcpy(ce->addr6.sin6_addr.s6_addr, 117 lip, sizeof(struct in6_addr)); 118 ret = clip6_get_mbox(dev, (const struct in6_addr *)lip); 119 if (ret) { 120 write_unlock_bh(&ctbl->lock); 121 dev_err(adap->pdev_dev, 122 "CLIP FW cmd failed with error %d, " 123 "Connections using %pI6c wont be " 124 "offloaded", 125 ret, ce->addr6.sin6_addr.s6_addr); 126 return ret; 127 } 128 } else { 129 ce->addr.sin_family = AF_INET; 130 memcpy((char *)(&ce->addr.sin_addr), lip, 131 sizeof(struct in_addr)); 132 } 133 } else { 134 write_unlock_bh(&ctbl->lock); 135 dev_info(adap->pdev_dev, "CLIP table overflow, " 136 "Connections using %pI6c wont be offloaded", 137 (void *)lip); 138 return -ENOMEM; 139 } 140 write_unlock_bh(&ctbl->lock); 141 found: 142 atomic_inc(&ce->refcnt); 143 144 return 0; 145 } 146 EXPORT_SYMBOL(cxgb4_clip_get); 147 148 void cxgb4_clip_release(const struct net_device *dev, const u32 *lip, u8 v6) 149 { 150 struct adapter *adap = netdev2adap(dev); 151 struct clip_tbl *ctbl = adap->clipt; 152 struct clip_entry *ce, *cte; 153 u32 *addr = (u32 *)lip; 154 int hash; 155 int ret = -1; 156 157 if (!ctbl) 158 return; 159 160 hash = clip_addr_hash(ctbl, addr, v6); 161 162 read_lock_bh(&ctbl->lock); 163 list_for_each_entry(cte, &ctbl->hash_list[hash], list) { 164 if (cte->addr6.sin6_family == AF_INET6 && v6) 165 ret = memcmp(lip, cte->addr6.sin6_addr.s6_addr, 166 sizeof(struct in6_addr)); 167 else if (cte->addr.sin_family == AF_INET && !v6) 168 ret = memcmp(lip, (char *)(&cte->addr.sin_addr), 169 sizeof(struct in_addr)); 170 if (!ret) { 171 ce = cte; 172 read_unlock_bh(&ctbl->lock); 173 goto found; 174 } 175 } 176 read_unlock_bh(&ctbl->lock); 177 178 return; 179 found: 180 write_lock_bh(&ctbl->lock); 181 spin_lock_bh(&ce->lock); 182 if (atomic_dec_and_test(&ce->refcnt)) { 183 list_del(&ce->list); 184 INIT_LIST_HEAD(&ce->list); 185 list_add_tail(&ce->list, &ctbl->ce_free_head); 186 atomic_inc(&ctbl->nfree); 187 if (v6) 188 clip6_release_mbox(dev, (const struct in6_addr *)lip); 189 } 190 spin_unlock_bh(&ce->lock); 191 write_unlock_bh(&ctbl->lock); 192 } 193 EXPORT_SYMBOL(cxgb4_clip_release); 194 195 /* Retrieves IPv6 addresses from a root device (bond, vlan) associated with 196 * a physical device. 197 * The physical device reference is needed to send the actul CLIP command. 198 */ 199 static int cxgb4_update_dev_clip(struct net_device *root_dev, 200 struct net_device *dev) 201 { 202 struct inet6_dev *idev = NULL; 203 struct inet6_ifaddr *ifa; 204 int ret = 0; 205 206 idev = __in6_dev_get(root_dev); 207 if (!idev) 208 return ret; 209 210 read_lock_bh(&idev->lock); 211 list_for_each_entry(ifa, &idev->addr_list, if_list) { 212 ret = cxgb4_clip_get(dev, (const u32 *)ifa->addr.s6_addr, 1); 213 if (ret < 0) 214 break; 215 } 216 read_unlock_bh(&idev->lock); 217 218 return ret; 219 } 220 221 int cxgb4_update_root_dev_clip(struct net_device *dev) 222 { 223 struct net_device *root_dev = NULL; 224 int i, ret = 0; 225 226 /* First populate the real net device's IPv6 addresses */ 227 ret = cxgb4_update_dev_clip(dev, dev); 228 if (ret) 229 return ret; 230 231 /* Parse all bond and vlan devices layered on top of the physical dev */ 232 root_dev = netdev_master_upper_dev_get_rcu(dev); 233 if (root_dev) { 234 ret = cxgb4_update_dev_clip(root_dev, dev); 235 if (ret) 236 return ret; 237 } 238 239 for (i = 0; i < VLAN_N_VID; i++) { 240 root_dev = __vlan_find_dev_deep_rcu(dev, htons(ETH_P_8021Q), i); 241 if (!root_dev) 242 continue; 243 244 ret = cxgb4_update_dev_clip(root_dev, dev); 245 if (ret) 246 break; 247 } 248 249 return ret; 250 } 251 EXPORT_SYMBOL(cxgb4_update_root_dev_clip); 252 253 int clip_tbl_show(struct seq_file *seq, void *v) 254 { 255 struct adapter *adapter = seq->private; 256 struct clip_tbl *ctbl = adapter->clipt; 257 struct clip_entry *ce; 258 char ip[60]; 259 int i; 260 261 read_lock_bh(&ctbl->lock); 262 263 seq_puts(seq, "IP Address Users\n"); 264 for (i = 0 ; i < ctbl->clipt_size; ++i) { 265 list_for_each_entry(ce, &ctbl->hash_list[i], list) { 266 ip[0] = '\0'; 267 sprintf(ip, "%pISc", &ce->addr); 268 seq_printf(seq, "%-25s %u\n", ip, 269 atomic_read(&ce->refcnt)); 270 } 271 } 272 seq_printf(seq, "Free clip entries : %d\n", atomic_read(&ctbl->nfree)); 273 274 read_unlock_bh(&ctbl->lock); 275 276 return 0; 277 } 278 279 struct clip_tbl *t4_init_clip_tbl(unsigned int clipt_start, 280 unsigned int clipt_end) 281 { 282 struct clip_entry *cl_list; 283 struct clip_tbl *ctbl; 284 unsigned int clipt_size; 285 int i; 286 287 if (clipt_start >= clipt_end) 288 return NULL; 289 clipt_size = clipt_end - clipt_start + 1; 290 if (clipt_size < CLIPT_MIN_HASH_BUCKETS) 291 return NULL; 292 293 ctbl = kvzalloc(sizeof(*ctbl) + 294 clipt_size*sizeof(struct list_head), GFP_KERNEL); 295 if (!ctbl) 296 return NULL; 297 298 ctbl->clipt_start = clipt_start; 299 ctbl->clipt_size = clipt_size; 300 INIT_LIST_HEAD(&ctbl->ce_free_head); 301 302 atomic_set(&ctbl->nfree, clipt_size); 303 rwlock_init(&ctbl->lock); 304 305 for (i = 0; i < ctbl->clipt_size; ++i) 306 INIT_LIST_HEAD(&ctbl->hash_list[i]); 307 308 cl_list = kvzalloc(clipt_size*sizeof(struct clip_entry), GFP_KERNEL); 309 if (!cl_list) { 310 kvfree(ctbl); 311 return NULL; 312 } 313 ctbl->cl_list = (void *)cl_list; 314 315 for (i = 0; i < clipt_size; i++) { 316 INIT_LIST_HEAD(&cl_list[i].list); 317 list_add_tail(&cl_list[i].list, &ctbl->ce_free_head); 318 } 319 320 return ctbl; 321 } 322 323 void t4_cleanup_clip_tbl(struct adapter *adap) 324 { 325 struct clip_tbl *ctbl = adap->clipt; 326 327 if (ctbl) { 328 if (ctbl->cl_list) 329 kvfree(ctbl->cl_list); 330 kvfree(ctbl); 331 } 332 } 333 EXPORT_SYMBOL(t4_cleanup_clip_tbl); 334