1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * lec.c: Lan Emulation driver 4 * 5 * Marko Kiiskila <mkiiskila@yahoo.com> 6 */ 7 8 #define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__ 9 10 #include <linux/slab.h> 11 #include <linux/kernel.h> 12 #include <linux/bitops.h> 13 #include <linux/capability.h> 14 15 /* We are ethernet device */ 16 #include <linux/if_ether.h> 17 #include <linux/netdevice.h> 18 #include <linux/etherdevice.h> 19 #include <net/sock.h> 20 #include <linux/skbuff.h> 21 #include <linux/ip.h> 22 #include <asm/byteorder.h> 23 #include <linux/uaccess.h> 24 #include <net/arp.h> 25 #include <net/dst.h> 26 #include <linux/proc_fs.h> 27 #include <linux/spinlock.h> 28 #include <linux/seq_file.h> 29 30 /* And atm device */ 31 #include <linux/atmdev.h> 32 #include <linux/atmlec.h> 33 34 /* Proxy LEC knows about bridging */ 35 #if IS_ENABLED(CONFIG_BRIDGE) 36 #include "../bridge/br_private.h" 37 38 static unsigned char bridge_ula_lec[] = { 0x01, 0x80, 0xc2, 0x00, 0x00 }; 39 #endif 40 41 /* Modular too */ 42 #include <linux/module.h> 43 #include <linux/init.h> 44 45 /* Hardening for Spectre-v1 */ 46 #include <linux/nospec.h> 47 48 #include "lec.h" 49 #include "lec_arpc.h" 50 #include "resources.h" 51 52 #define DUMP_PACKETS 0 /* 53 * 0 = None, 54 * 1 = 30 first bytes 55 * 2 = Whole packet 56 */ 57 58 #define LEC_UNRES_QUE_LEN 8 /* 59 * number of tx packets to queue for a 60 * single destination while waiting for SVC 61 */ 62 63 static int lec_open(struct net_device *dev); 64 static netdev_tx_t lec_start_xmit(struct sk_buff *skb, 65 struct net_device *dev); 66 static int lec_close(struct net_device *dev); 67 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv, 68 const unsigned char *mac_addr); 69 static int lec_arp_remove(struct lec_priv *priv, 70 struct lec_arp_table *to_remove); 71 /* LANE2 functions */ 72 static void lane2_associate_ind(struct net_device *dev, const u8 *mac_address, 73 const u8 *tlvs, u32 sizeoftlvs); 74 static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force, 75 u8 **tlvs, u32 *sizeoftlvs); 76 static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst, 77 const u8 *tlvs, u32 sizeoftlvs); 78 79 static int lec_addr_delete(struct lec_priv *priv, const unsigned char *atm_addr, 80 unsigned long permanent); 81 static void lec_arp_check_empties(struct lec_priv *priv, 82 struct atm_vcc *vcc, struct sk_buff *skb); 83 static void lec_arp_destroy(struct lec_priv *priv); 84 static void lec_arp_init(struct lec_priv *priv); 85 static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv, 86 const unsigned char *mac_to_find, 87 int is_rdesc, 88 struct lec_arp_table **ret_entry); 89 static void lec_arp_update(struct lec_priv *priv, const unsigned char *mac_addr, 90 const unsigned char *atm_addr, 91 unsigned long remoteflag, 92 unsigned int targetless_le_arp); 93 static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id); 94 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc); 95 static void lec_set_flush_tran_id(struct lec_priv *priv, 96 const unsigned char *atm_addr, 97 unsigned long tran_id); 98 static void lec_vcc_added(struct lec_priv *priv, 99 const struct atmlec_ioc *ioc_data, 100 struct atm_vcc *vcc, 101 void (*old_push)(struct atm_vcc *vcc, 102 struct sk_buff *skb)); 103 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc); 104 105 /* must be done under lec_arp_lock */ 106 static inline void lec_arp_hold(struct lec_arp_table *entry) 107 { 108 refcount_inc(&entry->usage); 109 } 110 111 static inline void lec_arp_put(struct lec_arp_table *entry) 112 { 113 if (refcount_dec_and_test(&entry->usage)) 114 kfree(entry); 115 } 116 117 static struct lane2_ops lane2_ops = { 118 .resolve = lane2_resolve, /* spec 3.1.3 */ 119 .associate_req = lane2_associate_req, /* spec 3.1.4 */ 120 .associate_indicator = NULL /* spec 3.1.5 */ 121 }; 122 123 static unsigned char bus_mac[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff }; 124 125 /* Device structures */ 126 static struct net_device *dev_lec[MAX_LEC_ITF]; 127 128 #if IS_ENABLED(CONFIG_BRIDGE) 129 static void lec_handle_bridge(struct sk_buff *skb, struct net_device *dev) 130 { 131 char *buff; 132 struct lec_priv *priv; 133 134 /* 135 * Check if this is a BPDU. If so, ask zeppelin to send 136 * LE_TOPOLOGY_REQUEST with the same value of Topology Change bit 137 * as the Config BPDU has 138 */ 139 buff = skb->data + skb->dev->hard_header_len; 140 if (*buff++ == 0x42 && *buff++ == 0x42 && *buff++ == 0x03) { 141 struct sock *sk; 142 struct sk_buff *skb2; 143 struct atmlec_msg *mesg; 144 145 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC); 146 if (skb2 == NULL) 147 return; 148 skb2->len = sizeof(struct atmlec_msg); 149 mesg = (struct atmlec_msg *)skb2->data; 150 mesg->type = l_topology_change; 151 buff += 4; 152 mesg->content.normal.flag = *buff & 0x01; 153 /* 0x01 is topology change */ 154 155 priv = netdev_priv(dev); 156 atm_force_charge(priv->lecd, skb2->truesize); 157 sk = sk_atm(priv->lecd); 158 skb_queue_tail(&sk->sk_receive_queue, skb2); 159 sk->sk_data_ready(sk); 160 } 161 } 162 #endif /* IS_ENABLED(CONFIG_BRIDGE) */ 163 164 /* 165 * Open/initialize the netdevice. This is called (in the current kernel) 166 * sometime after booting when the 'ifconfig' program is run. 167 * 168 * This routine should set everything up anew at each open, even 169 * registers that "should" only need to be set once at boot, so that 170 * there is non-reboot way to recover if something goes wrong. 171 */ 172 173 static int lec_open(struct net_device *dev) 174 { 175 netif_start_queue(dev); 176 177 return 0; 178 } 179 180 static void 181 lec_send(struct atm_vcc *vcc, struct sk_buff *skb) 182 { 183 struct net_device *dev = skb->dev; 184 185 ATM_SKB(skb)->vcc = vcc; 186 atm_account_tx(vcc, skb); 187 188 if (vcc->send(vcc, skb) < 0) { 189 dev->stats.tx_dropped++; 190 return; 191 } 192 193 dev->stats.tx_packets++; 194 dev->stats.tx_bytes += skb->len; 195 } 196 197 static void lec_tx_timeout(struct net_device *dev, unsigned int txqueue) 198 { 199 pr_info("%s\n", dev->name); 200 netif_trans_update(dev); 201 netif_wake_queue(dev); 202 } 203 204 static netdev_tx_t lec_start_xmit(struct sk_buff *skb, 205 struct net_device *dev) 206 { 207 struct sk_buff *skb2; 208 struct lec_priv *priv = netdev_priv(dev); 209 struct lecdatahdr_8023 *lec_h; 210 struct atm_vcc *vcc; 211 struct lec_arp_table *entry; 212 unsigned char *dst; 213 int min_frame_size; 214 int is_rdesc; 215 216 pr_debug("called\n"); 217 if (!priv->lecd) { 218 pr_info("%s:No lecd attached\n", dev->name); 219 dev->stats.tx_errors++; 220 netif_stop_queue(dev); 221 kfree_skb(skb); 222 return NETDEV_TX_OK; 223 } 224 225 pr_debug("skbuff head:%lx data:%lx tail:%lx end:%lx\n", 226 (long)skb->head, (long)skb->data, (long)skb_tail_pointer(skb), 227 (long)skb_end_pointer(skb)); 228 #if IS_ENABLED(CONFIG_BRIDGE) 229 if (memcmp(skb->data, bridge_ula_lec, sizeof(bridge_ula_lec)) == 0) 230 lec_handle_bridge(skb, dev); 231 #endif 232 233 /* Make sure we have room for lec_id */ 234 if (skb_headroom(skb) < 2) { 235 pr_debug("reallocating skb\n"); 236 skb2 = skb_realloc_headroom(skb, LEC_HEADER_LEN); 237 if (unlikely(!skb2)) { 238 kfree_skb(skb); 239 return NETDEV_TX_OK; 240 } 241 consume_skb(skb); 242 skb = skb2; 243 } 244 skb_push(skb, 2); 245 246 /* Put le header to place */ 247 lec_h = (struct lecdatahdr_8023 *)skb->data; 248 lec_h->le_header = htons(priv->lecid); 249 250 #if DUMP_PACKETS >= 2 251 #define MAX_DUMP_SKB 99 252 #elif DUMP_PACKETS >= 1 253 #define MAX_DUMP_SKB 30 254 #endif 255 #if DUMP_PACKETS >= 1 256 printk(KERN_DEBUG "%s: send datalen:%ld lecid:%4.4x\n", 257 dev->name, skb->len, priv->lecid); 258 print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1, 259 skb->data, min(skb->len, MAX_DUMP_SKB), true); 260 #endif /* DUMP_PACKETS >= 1 */ 261 262 /* Minimum ethernet-frame size */ 263 min_frame_size = LEC_MINIMUM_8023_SIZE; 264 if (skb->len < min_frame_size) { 265 if ((skb->len + skb_tailroom(skb)) < min_frame_size) { 266 skb2 = skb_copy_expand(skb, 0, 267 min_frame_size - skb->truesize, 268 GFP_ATOMIC); 269 dev_kfree_skb(skb); 270 if (skb2 == NULL) { 271 dev->stats.tx_dropped++; 272 return NETDEV_TX_OK; 273 } 274 skb = skb2; 275 } 276 skb_put(skb, min_frame_size - skb->len); 277 } 278 279 /* Send to right vcc */ 280 is_rdesc = 0; 281 dst = lec_h->h_dest; 282 entry = NULL; 283 vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry); 284 pr_debug("%s:vcc:%p vcc_flags:%lx, entry:%p\n", 285 dev->name, vcc, vcc ? vcc->flags : 0, entry); 286 if (!vcc || !test_bit(ATM_VF_READY, &vcc->flags)) { 287 if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) { 288 pr_debug("%s:queuing packet, MAC address %pM\n", 289 dev->name, lec_h->h_dest); 290 skb_queue_tail(&entry->tx_wait, skb); 291 } else { 292 pr_debug("%s:tx queue full or no arp entry, dropping, MAC address: %pM\n", 293 dev->name, lec_h->h_dest); 294 dev->stats.tx_dropped++; 295 dev_kfree_skb(skb); 296 } 297 goto out; 298 } 299 #if DUMP_PACKETS > 0 300 printk(KERN_DEBUG "%s:sending to vpi:%d vci:%d\n", 301 dev->name, vcc->vpi, vcc->vci); 302 #endif /* DUMP_PACKETS > 0 */ 303 304 while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) { 305 pr_debug("emptying tx queue, MAC address %pM\n", lec_h->h_dest); 306 lec_send(vcc, skb2); 307 } 308 309 lec_send(vcc, skb); 310 311 if (!atm_may_send(vcc, 0)) { 312 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 313 314 vpriv->xoff = 1; 315 netif_stop_queue(dev); 316 317 /* 318 * vcc->pop() might have occurred in between, making 319 * the vcc usuable again. Since xmit is serialized, 320 * this is the only situation we have to re-test. 321 */ 322 323 if (atm_may_send(vcc, 0)) 324 netif_wake_queue(dev); 325 } 326 327 out: 328 if (entry) 329 lec_arp_put(entry); 330 netif_trans_update(dev); 331 return NETDEV_TX_OK; 332 } 333 334 /* The inverse routine to net_open(). */ 335 static int lec_close(struct net_device *dev) 336 { 337 netif_stop_queue(dev); 338 return 0; 339 } 340 341 static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb) 342 { 343 static const u8 zero_addr[ETH_ALEN] = {}; 344 unsigned long flags; 345 struct net_device *dev = (struct net_device *)vcc->proto_data; 346 struct lec_priv *priv = netdev_priv(dev); 347 struct atmlec_msg *mesg; 348 struct lec_arp_table *entry; 349 char *tmp; /* FIXME */ 350 351 WARN_ON(refcount_sub_and_test(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc)); 352 mesg = (struct atmlec_msg *)skb->data; 353 tmp = skb->data; 354 tmp += sizeof(struct atmlec_msg); 355 pr_debug("%s: msg from zeppelin:%d\n", dev->name, mesg->type); 356 switch (mesg->type) { 357 case l_set_mac_addr: 358 eth_hw_addr_set(dev, mesg->content.normal.mac_addr); 359 break; 360 case l_del_mac_addr: 361 eth_hw_addr_set(dev, zero_addr); 362 break; 363 case l_addr_delete: 364 lec_addr_delete(priv, mesg->content.normal.atm_addr, 365 mesg->content.normal.flag); 366 break; 367 case l_topology_change: 368 priv->topology_change = mesg->content.normal.flag; 369 break; 370 case l_flush_complete: 371 lec_flush_complete(priv, mesg->content.normal.flag); 372 break; 373 case l_narp_req: /* LANE2: see 7.1.35 in the lane2 spec */ 374 spin_lock_irqsave(&priv->lec_arp_lock, flags); 375 entry = lec_arp_find(priv, mesg->content.normal.mac_addr); 376 lec_arp_remove(priv, entry); 377 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 378 379 if (mesg->content.normal.no_source_le_narp) 380 break; 381 fallthrough; 382 case l_arp_update: 383 lec_arp_update(priv, mesg->content.normal.mac_addr, 384 mesg->content.normal.atm_addr, 385 mesg->content.normal.flag, 386 mesg->content.normal.targetless_le_arp); 387 pr_debug("in l_arp_update\n"); 388 if (mesg->sizeoftlvs != 0) { /* LANE2 3.1.5 */ 389 pr_debug("LANE2 3.1.5, got tlvs, size %d\n", 390 mesg->sizeoftlvs); 391 lane2_associate_ind(dev, mesg->content.normal.mac_addr, 392 tmp, mesg->sizeoftlvs); 393 } 394 break; 395 case l_config: 396 priv->maximum_unknown_frame_count = 397 mesg->content.config.maximum_unknown_frame_count; 398 priv->max_unknown_frame_time = 399 (mesg->content.config.max_unknown_frame_time * HZ); 400 priv->max_retry_count = mesg->content.config.max_retry_count; 401 priv->aging_time = (mesg->content.config.aging_time * HZ); 402 priv->forward_delay_time = 403 (mesg->content.config.forward_delay_time * HZ); 404 priv->arp_response_time = 405 (mesg->content.config.arp_response_time * HZ); 406 priv->flush_timeout = (mesg->content.config.flush_timeout * HZ); 407 priv->path_switching_delay = 408 (mesg->content.config.path_switching_delay * HZ); 409 priv->lane_version = mesg->content.config.lane_version; 410 /* LANE2 */ 411 priv->lane2_ops = NULL; 412 if (priv->lane_version > 1) 413 priv->lane2_ops = &lane2_ops; 414 rtnl_lock(); 415 if (dev_set_mtu(dev, mesg->content.config.mtu)) 416 pr_info("%s: change_mtu to %d failed\n", 417 dev->name, mesg->content.config.mtu); 418 rtnl_unlock(); 419 priv->is_proxy = mesg->content.config.is_proxy; 420 break; 421 case l_flush_tran_id: 422 lec_set_flush_tran_id(priv, mesg->content.normal.atm_addr, 423 mesg->content.normal.flag); 424 break; 425 case l_set_lecid: 426 priv->lecid = 427 (unsigned short)(0xffff & mesg->content.normal.flag); 428 break; 429 case l_should_bridge: 430 #if IS_ENABLED(CONFIG_BRIDGE) 431 { 432 pr_debug("%s: bridge zeppelin asks about %pM\n", 433 dev->name, mesg->content.proxy.mac_addr); 434 435 if (br_fdb_test_addr_hook == NULL) 436 break; 437 438 if (br_fdb_test_addr_hook(dev, mesg->content.proxy.mac_addr)) { 439 /* hit from bridge table, send LE_ARP_RESPONSE */ 440 struct sk_buff *skb2; 441 struct sock *sk; 442 443 pr_debug("%s: entry found, responding to zeppelin\n", 444 dev->name); 445 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC); 446 if (skb2 == NULL) 447 break; 448 skb2->len = sizeof(struct atmlec_msg); 449 skb_copy_to_linear_data(skb2, mesg, sizeof(*mesg)); 450 atm_force_charge(priv->lecd, skb2->truesize); 451 sk = sk_atm(priv->lecd); 452 skb_queue_tail(&sk->sk_receive_queue, skb2); 453 sk->sk_data_ready(sk); 454 } 455 } 456 #endif /* IS_ENABLED(CONFIG_BRIDGE) */ 457 break; 458 default: 459 pr_info("%s: Unknown message type %d\n", dev->name, mesg->type); 460 dev_kfree_skb(skb); 461 return -EINVAL; 462 } 463 dev_kfree_skb(skb); 464 return 0; 465 } 466 467 static void lec_atm_close(struct atm_vcc *vcc) 468 { 469 struct sk_buff *skb; 470 struct net_device *dev = (struct net_device *)vcc->proto_data; 471 struct lec_priv *priv = netdev_priv(dev); 472 473 priv->lecd = NULL; 474 /* Do something needful? */ 475 476 netif_stop_queue(dev); 477 lec_arp_destroy(priv); 478 479 if (skb_peek(&sk_atm(vcc)->sk_receive_queue)) 480 pr_info("%s closing with messages pending\n", dev->name); 481 while ((skb = skb_dequeue(&sk_atm(vcc)->sk_receive_queue))) { 482 atm_return(vcc, skb->truesize); 483 dev_kfree_skb(skb); 484 } 485 486 pr_info("%s: Shut down!\n", dev->name); 487 module_put(THIS_MODULE); 488 } 489 490 static const struct atmdev_ops lecdev_ops = { 491 .close = lec_atm_close, 492 .send = lec_atm_send 493 }; 494 495 static struct atm_dev lecatm_dev = { 496 .ops = &lecdev_ops, 497 .type = "lec", 498 .number = 999, /* dummy device number */ 499 .lock = __SPIN_LOCK_UNLOCKED(lecatm_dev.lock) 500 }; 501 502 /* 503 * LANE2: new argument struct sk_buff *data contains 504 * the LE_ARP based TLVs introduced in the LANE2 spec 505 */ 506 static int 507 send_to_lecd(struct lec_priv *priv, atmlec_msg_type type, 508 const unsigned char *mac_addr, const unsigned char *atm_addr, 509 struct sk_buff *data) 510 { 511 struct sock *sk; 512 struct sk_buff *skb; 513 struct atmlec_msg *mesg; 514 515 if (!priv || !priv->lecd) 516 return -1; 517 skb = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC); 518 if (!skb) 519 return -1; 520 skb->len = sizeof(struct atmlec_msg); 521 mesg = (struct atmlec_msg *)skb->data; 522 memset(mesg, 0, sizeof(struct atmlec_msg)); 523 mesg->type = type; 524 if (data != NULL) 525 mesg->sizeoftlvs = data->len; 526 if (mac_addr) 527 ether_addr_copy(mesg->content.normal.mac_addr, mac_addr); 528 else 529 mesg->content.normal.targetless_le_arp = 1; 530 if (atm_addr) 531 memcpy(&mesg->content.normal.atm_addr, atm_addr, ATM_ESA_LEN); 532 533 atm_force_charge(priv->lecd, skb->truesize); 534 sk = sk_atm(priv->lecd); 535 skb_queue_tail(&sk->sk_receive_queue, skb); 536 sk->sk_data_ready(sk); 537 538 if (data != NULL) { 539 pr_debug("about to send %d bytes of data\n", data->len); 540 atm_force_charge(priv->lecd, data->truesize); 541 skb_queue_tail(&sk->sk_receive_queue, data); 542 sk->sk_data_ready(sk); 543 } 544 545 return 0; 546 } 547 548 static void lec_set_multicast_list(struct net_device *dev) 549 { 550 /* 551 * by default, all multicast frames arrive over the bus. 552 * eventually support selective multicast service 553 */ 554 } 555 556 static const struct net_device_ops lec_netdev_ops = { 557 .ndo_open = lec_open, 558 .ndo_stop = lec_close, 559 .ndo_start_xmit = lec_start_xmit, 560 .ndo_tx_timeout = lec_tx_timeout, 561 .ndo_set_rx_mode = lec_set_multicast_list, 562 }; 563 564 static const unsigned char lec_ctrl_magic[] = { 565 0xff, 566 0x00, 567 0x01, 568 0x01 569 }; 570 571 #define LEC_DATA_DIRECT_8023 2 572 #define LEC_DATA_DIRECT_8025 3 573 574 static int lec_is_data_direct(struct atm_vcc *vcc) 575 { 576 return ((vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8023) || 577 (vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8025)); 578 } 579 580 static void lec_push(struct atm_vcc *vcc, struct sk_buff *skb) 581 { 582 unsigned long flags; 583 struct net_device *dev = (struct net_device *)vcc->proto_data; 584 struct lec_priv *priv = netdev_priv(dev); 585 586 #if DUMP_PACKETS > 0 587 printk(KERN_DEBUG "%s: vcc vpi:%d vci:%d\n", 588 dev->name, vcc->vpi, vcc->vci); 589 #endif 590 if (!skb) { 591 pr_debug("%s: null skb\n", dev->name); 592 lec_vcc_close(priv, vcc); 593 return; 594 } 595 #if DUMP_PACKETS >= 2 596 #define MAX_SKB_DUMP 99 597 #elif DUMP_PACKETS >= 1 598 #define MAX_SKB_DUMP 30 599 #endif 600 #if DUMP_PACKETS > 0 601 printk(KERN_DEBUG "%s: rcv datalen:%ld lecid:%4.4x\n", 602 dev->name, skb->len, priv->lecid); 603 print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1, 604 skb->data, min(MAX_SKB_DUMP, skb->len), true); 605 #endif /* DUMP_PACKETS > 0 */ 606 if (memcmp(skb->data, lec_ctrl_magic, 4) == 0) { 607 /* Control frame, to daemon */ 608 struct sock *sk = sk_atm(vcc); 609 610 pr_debug("%s: To daemon\n", dev->name); 611 skb_queue_tail(&sk->sk_receive_queue, skb); 612 sk->sk_data_ready(sk); 613 } else { /* Data frame, queue to protocol handlers */ 614 struct lec_arp_table *entry; 615 unsigned char *src, *dst; 616 617 atm_return(vcc, skb->truesize); 618 if (*(__be16 *) skb->data == htons(priv->lecid) || 619 !priv->lecd || !(dev->flags & IFF_UP)) { 620 /* 621 * Probably looping back, or if lecd is missing, 622 * lecd has gone down 623 */ 624 pr_debug("Ignoring frame...\n"); 625 dev_kfree_skb(skb); 626 return; 627 } 628 dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest; 629 630 /* 631 * If this is a Data Direct VCC, and the VCC does not match 632 * the LE_ARP cache entry, delete the LE_ARP cache entry. 633 */ 634 spin_lock_irqsave(&priv->lec_arp_lock, flags); 635 if (lec_is_data_direct(vcc)) { 636 src = ((struct lecdatahdr_8023 *)skb->data)->h_source; 637 entry = lec_arp_find(priv, src); 638 if (entry && entry->vcc != vcc) { 639 lec_arp_remove(priv, entry); 640 lec_arp_put(entry); 641 } 642 } 643 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 644 645 if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */ 646 !priv->is_proxy && /* Proxy wants all the packets */ 647 memcmp(dst, dev->dev_addr, dev->addr_len)) { 648 dev_kfree_skb(skb); 649 return; 650 } 651 if (!hlist_empty(&priv->lec_arp_empty_ones)) 652 lec_arp_check_empties(priv, vcc, skb); 653 skb_pull(skb, 2); /* skip lec_id */ 654 skb->protocol = eth_type_trans(skb, dev); 655 dev->stats.rx_packets++; 656 dev->stats.rx_bytes += skb->len; 657 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data)); 658 netif_rx(skb); 659 } 660 } 661 662 static void lec_pop(struct atm_vcc *vcc, struct sk_buff *skb) 663 { 664 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 665 struct net_device *dev = skb->dev; 666 667 if (vpriv == NULL) { 668 pr_info("vpriv = NULL!?!?!?\n"); 669 return; 670 } 671 672 vpriv->old_pop(vcc, skb); 673 674 if (vpriv->xoff && atm_may_send(vcc, 0)) { 675 vpriv->xoff = 0; 676 if (netif_running(dev) && netif_queue_stopped(dev)) 677 netif_wake_queue(dev); 678 } 679 } 680 681 static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg) 682 { 683 struct lec_vcc_priv *vpriv; 684 int bytes_left; 685 struct atmlec_ioc ioc_data; 686 687 /* Lecd must be up in this case */ 688 bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc)); 689 if (bytes_left != 0) 690 pr_info("copy from user failed for %d bytes\n", bytes_left); 691 if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF) 692 return -EINVAL; 693 ioc_data.dev_num = array_index_nospec(ioc_data.dev_num, MAX_LEC_ITF); 694 if (!dev_lec[ioc_data.dev_num]) 695 return -EINVAL; 696 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 697 if (!vpriv) 698 return -ENOMEM; 699 vpriv->xoff = 0; 700 vpriv->old_pop = vcc->pop; 701 vcc->user_back = vpriv; 702 vcc->pop = lec_pop; 703 lec_vcc_added(netdev_priv(dev_lec[ioc_data.dev_num]), 704 &ioc_data, vcc, vcc->push); 705 vcc->proto_data = dev_lec[ioc_data.dev_num]; 706 vcc->push = lec_push; 707 return 0; 708 } 709 710 static int lec_mcast_attach(struct atm_vcc *vcc, int arg) 711 { 712 if (arg < 0 || arg >= MAX_LEC_ITF) 713 return -EINVAL; 714 arg = array_index_nospec(arg, MAX_LEC_ITF); 715 if (!dev_lec[arg]) 716 return -EINVAL; 717 vcc->proto_data = dev_lec[arg]; 718 return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc); 719 } 720 721 /* Initialize device. */ 722 static int lecd_attach(struct atm_vcc *vcc, int arg) 723 { 724 int i; 725 struct lec_priv *priv; 726 727 if (arg < 0) 728 arg = 0; 729 if (arg >= MAX_LEC_ITF) 730 return -EINVAL; 731 i = array_index_nospec(arg, MAX_LEC_ITF); 732 if (!dev_lec[i]) { 733 int size; 734 735 size = sizeof(struct lec_priv); 736 dev_lec[i] = alloc_etherdev(size); 737 if (!dev_lec[i]) 738 return -ENOMEM; 739 dev_lec[i]->netdev_ops = &lec_netdev_ops; 740 dev_lec[i]->max_mtu = 18190; 741 snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i); 742 if (register_netdev(dev_lec[i])) { 743 free_netdev(dev_lec[i]); 744 return -EINVAL; 745 } 746 747 priv = netdev_priv(dev_lec[i]); 748 } else { 749 priv = netdev_priv(dev_lec[i]); 750 if (priv->lecd) 751 return -EADDRINUSE; 752 } 753 lec_arp_init(priv); 754 priv->itfnum = i; /* LANE2 addition */ 755 priv->lecd = vcc; 756 vcc->dev = &lecatm_dev; 757 vcc_insert_socket(sk_atm(vcc)); 758 759 vcc->proto_data = dev_lec[i]; 760 set_bit(ATM_VF_META, &vcc->flags); 761 set_bit(ATM_VF_READY, &vcc->flags); 762 763 /* Set default values to these variables */ 764 priv->maximum_unknown_frame_count = 1; 765 priv->max_unknown_frame_time = (1 * HZ); 766 priv->vcc_timeout_period = (1200 * HZ); 767 priv->max_retry_count = 1; 768 priv->aging_time = (300 * HZ); 769 priv->forward_delay_time = (15 * HZ); 770 priv->topology_change = 0; 771 priv->arp_response_time = (1 * HZ); 772 priv->flush_timeout = (4 * HZ); 773 priv->path_switching_delay = (6 * HZ); 774 775 if (dev_lec[i]->flags & IFF_UP) 776 netif_start_queue(dev_lec[i]); 777 __module_get(THIS_MODULE); 778 return i; 779 } 780 781 #ifdef CONFIG_PROC_FS 782 static const char *lec_arp_get_status_string(unsigned char status) 783 { 784 static const char *const lec_arp_status_string[] = { 785 "ESI_UNKNOWN ", 786 "ESI_ARP_PENDING ", 787 "ESI_VC_PENDING ", 788 "<Undefined> ", 789 "ESI_FLUSH_PENDING ", 790 "ESI_FORWARD_DIRECT" 791 }; 792 793 if (status > ESI_FORWARD_DIRECT) 794 status = 3; /* ESI_UNDEFINED */ 795 return lec_arp_status_string[status]; 796 } 797 798 static void lec_info(struct seq_file *seq, struct lec_arp_table *entry) 799 { 800 seq_printf(seq, "%pM ", entry->mac_addr); 801 seq_printf(seq, "%*phN ", ATM_ESA_LEN, entry->atm_addr); 802 seq_printf(seq, "%s %4.4x", lec_arp_get_status_string(entry->status), 803 entry->flags & 0xffff); 804 if (entry->vcc) 805 seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci); 806 else 807 seq_printf(seq, " "); 808 if (entry->recv_vcc) { 809 seq_printf(seq, " %3d %3d", entry->recv_vcc->vpi, 810 entry->recv_vcc->vci); 811 } 812 seq_putc(seq, '\n'); 813 } 814 815 struct lec_state { 816 unsigned long flags; 817 struct lec_priv *locked; 818 struct hlist_node *node; 819 struct net_device *dev; 820 int itf; 821 int arp_table; 822 int misc_table; 823 }; 824 825 static void *lec_tbl_walk(struct lec_state *state, struct hlist_head *tbl, 826 loff_t *l) 827 { 828 struct hlist_node *e = state->node; 829 830 if (!e) 831 e = tbl->first; 832 if (e == SEQ_START_TOKEN) { 833 e = tbl->first; 834 --*l; 835 } 836 837 for (; e; e = e->next) { 838 if (--*l < 0) 839 break; 840 } 841 state->node = e; 842 843 return (*l < 0) ? state : NULL; 844 } 845 846 static void *lec_arp_walk(struct lec_state *state, loff_t *l, 847 struct lec_priv *priv) 848 { 849 void *v = NULL; 850 int p; 851 852 for (p = state->arp_table; p < LEC_ARP_TABLE_SIZE; p++) { 853 v = lec_tbl_walk(state, &priv->lec_arp_tables[p], l); 854 if (v) 855 break; 856 } 857 state->arp_table = p; 858 return v; 859 } 860 861 static void *lec_misc_walk(struct lec_state *state, loff_t *l, 862 struct lec_priv *priv) 863 { 864 struct hlist_head *lec_misc_tables[] = { 865 &priv->lec_arp_empty_ones, 866 &priv->lec_no_forward, 867 &priv->mcast_fwds 868 }; 869 void *v = NULL; 870 int q; 871 872 for (q = state->misc_table; q < ARRAY_SIZE(lec_misc_tables); q++) { 873 v = lec_tbl_walk(state, lec_misc_tables[q], l); 874 if (v) 875 break; 876 } 877 state->misc_table = q; 878 return v; 879 } 880 881 static void *lec_priv_walk(struct lec_state *state, loff_t *l, 882 struct lec_priv *priv) 883 { 884 if (!state->locked) { 885 state->locked = priv; 886 spin_lock_irqsave(&priv->lec_arp_lock, state->flags); 887 } 888 if (!lec_arp_walk(state, l, priv) && !lec_misc_walk(state, l, priv)) { 889 spin_unlock_irqrestore(&priv->lec_arp_lock, state->flags); 890 state->locked = NULL; 891 /* Partial state reset for the next time we get called */ 892 state->arp_table = state->misc_table = 0; 893 } 894 return state->locked; 895 } 896 897 static void *lec_itf_walk(struct lec_state *state, loff_t *l) 898 { 899 struct net_device *dev; 900 void *v; 901 902 dev = state->dev ? state->dev : dev_lec[state->itf]; 903 v = (dev && netdev_priv(dev)) ? 904 lec_priv_walk(state, l, netdev_priv(dev)) : NULL; 905 if (!v && dev) { 906 dev_put(dev); 907 /* Partial state reset for the next time we get called */ 908 dev = NULL; 909 } 910 state->dev = dev; 911 return v; 912 } 913 914 static void *lec_get_idx(struct lec_state *state, loff_t l) 915 { 916 void *v = NULL; 917 918 for (; state->itf < MAX_LEC_ITF; state->itf++) { 919 v = lec_itf_walk(state, &l); 920 if (v) 921 break; 922 } 923 return v; 924 } 925 926 static void *lec_seq_start(struct seq_file *seq, loff_t *pos) 927 { 928 struct lec_state *state = seq->private; 929 930 state->itf = 0; 931 state->dev = NULL; 932 state->locked = NULL; 933 state->arp_table = 0; 934 state->misc_table = 0; 935 state->node = SEQ_START_TOKEN; 936 937 return *pos ? lec_get_idx(state, *pos) : SEQ_START_TOKEN; 938 } 939 940 static void lec_seq_stop(struct seq_file *seq, void *v) 941 { 942 struct lec_state *state = seq->private; 943 944 if (state->dev) { 945 spin_unlock_irqrestore(&state->locked->lec_arp_lock, 946 state->flags); 947 dev_put(state->dev); 948 } 949 } 950 951 static void *lec_seq_next(struct seq_file *seq, void *v, loff_t *pos) 952 { 953 struct lec_state *state = seq->private; 954 955 ++*pos; 956 return lec_get_idx(state, 1); 957 } 958 959 static int lec_seq_show(struct seq_file *seq, void *v) 960 { 961 static const char lec_banner[] = 962 "Itf MAC ATM destination" 963 " Status Flags " 964 "VPI/VCI Recv VPI/VCI\n"; 965 966 if (v == SEQ_START_TOKEN) 967 seq_puts(seq, lec_banner); 968 else { 969 struct lec_state *state = seq->private; 970 struct net_device *dev = state->dev; 971 struct lec_arp_table *entry = hlist_entry(state->node, 972 struct lec_arp_table, 973 next); 974 975 seq_printf(seq, "%s ", dev->name); 976 lec_info(seq, entry); 977 } 978 return 0; 979 } 980 981 static const struct seq_operations lec_seq_ops = { 982 .start = lec_seq_start, 983 .next = lec_seq_next, 984 .stop = lec_seq_stop, 985 .show = lec_seq_show, 986 }; 987 #endif 988 989 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 990 { 991 struct atm_vcc *vcc = ATM_SD(sock); 992 int err = 0; 993 994 switch (cmd) { 995 case ATMLEC_CTRL: 996 case ATMLEC_MCAST: 997 case ATMLEC_DATA: 998 if (!capable(CAP_NET_ADMIN)) 999 return -EPERM; 1000 break; 1001 default: 1002 return -ENOIOCTLCMD; 1003 } 1004 1005 switch (cmd) { 1006 case ATMLEC_CTRL: 1007 err = lecd_attach(vcc, (int)arg); 1008 if (err >= 0) 1009 sock->state = SS_CONNECTED; 1010 break; 1011 case ATMLEC_MCAST: 1012 err = lec_mcast_attach(vcc, (int)arg); 1013 break; 1014 case ATMLEC_DATA: 1015 err = lec_vcc_attach(vcc, (void __user *)arg); 1016 break; 1017 } 1018 1019 return err; 1020 } 1021 1022 static struct atm_ioctl lane_ioctl_ops = { 1023 .owner = THIS_MODULE, 1024 .ioctl = lane_ioctl, 1025 }; 1026 1027 static int __init lane_module_init(void) 1028 { 1029 #ifdef CONFIG_PROC_FS 1030 struct proc_dir_entry *p; 1031 1032 p = proc_create_seq_private("lec", 0444, atm_proc_root, &lec_seq_ops, 1033 sizeof(struct lec_state), NULL); 1034 if (!p) { 1035 pr_err("Unable to initialize /proc/net/atm/lec\n"); 1036 return -ENOMEM; 1037 } 1038 #endif 1039 1040 register_atm_ioctl(&lane_ioctl_ops); 1041 pr_info("lec.c: initialized\n"); 1042 return 0; 1043 } 1044 1045 static void __exit lane_module_cleanup(void) 1046 { 1047 int i; 1048 1049 #ifdef CONFIG_PROC_FS 1050 remove_proc_entry("lec", atm_proc_root); 1051 #endif 1052 1053 deregister_atm_ioctl(&lane_ioctl_ops); 1054 1055 for (i = 0; i < MAX_LEC_ITF; i++) { 1056 if (dev_lec[i] != NULL) { 1057 unregister_netdev(dev_lec[i]); 1058 free_netdev(dev_lec[i]); 1059 dev_lec[i] = NULL; 1060 } 1061 } 1062 } 1063 1064 module_init(lane_module_init); 1065 module_exit(lane_module_cleanup); 1066 1067 /* 1068 * LANE2: 3.1.3, LE_RESOLVE.request 1069 * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs. 1070 * If sizeoftlvs == NULL the default TLVs associated with this 1071 * lec will be used. 1072 * If dst_mac == NULL, targetless LE_ARP will be sent 1073 */ 1074 static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force, 1075 u8 **tlvs, u32 *sizeoftlvs) 1076 { 1077 unsigned long flags; 1078 struct lec_priv *priv = netdev_priv(dev); 1079 struct lec_arp_table *table; 1080 struct sk_buff *skb; 1081 int retval; 1082 1083 if (force == 0) { 1084 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1085 table = lec_arp_find(priv, dst_mac); 1086 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1087 if (table == NULL) 1088 return -1; 1089 1090 *tlvs = kmemdup(table->tlvs, table->sizeoftlvs, GFP_ATOMIC); 1091 if (*tlvs == NULL) 1092 return -1; 1093 1094 *sizeoftlvs = table->sizeoftlvs; 1095 1096 return 0; 1097 } 1098 1099 if (sizeoftlvs == NULL) 1100 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL); 1101 1102 else { 1103 skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC); 1104 if (skb == NULL) 1105 return -1; 1106 skb->len = *sizeoftlvs; 1107 skb_copy_to_linear_data(skb, *tlvs, *sizeoftlvs); 1108 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb); 1109 } 1110 return retval; 1111 } 1112 1113 /* 1114 * LANE2: 3.1.4, LE_ASSOCIATE.request 1115 * Associate the *tlvs with the *lan_dst address. 1116 * Will overwrite any previous association 1117 * Returns 1 for success, 0 for failure (out of memory) 1118 * 1119 */ 1120 static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst, 1121 const u8 *tlvs, u32 sizeoftlvs) 1122 { 1123 int retval; 1124 struct sk_buff *skb; 1125 struct lec_priv *priv = netdev_priv(dev); 1126 1127 if (!ether_addr_equal(lan_dst, dev->dev_addr)) 1128 return 0; /* not our mac address */ 1129 1130 kfree(priv->tlvs); /* NULL if there was no previous association */ 1131 1132 priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1133 if (priv->tlvs == NULL) 1134 return 0; 1135 priv->sizeoftlvs = sizeoftlvs; 1136 1137 skb = alloc_skb(sizeoftlvs, GFP_ATOMIC); 1138 if (skb == NULL) 1139 return 0; 1140 skb->len = sizeoftlvs; 1141 skb_copy_to_linear_data(skb, tlvs, sizeoftlvs); 1142 retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb); 1143 if (retval != 0) 1144 pr_info("lec.c: lane2_associate_req() failed\n"); 1145 /* 1146 * If the previous association has changed we must 1147 * somehow notify other LANE entities about the change 1148 */ 1149 return 1; 1150 } 1151 1152 /* 1153 * LANE2: 3.1.5, LE_ASSOCIATE.indication 1154 * 1155 */ 1156 static void lane2_associate_ind(struct net_device *dev, const u8 *mac_addr, 1157 const u8 *tlvs, u32 sizeoftlvs) 1158 { 1159 #if 0 1160 int i = 0; 1161 #endif 1162 struct lec_priv *priv = netdev_priv(dev); 1163 #if 0 /* 1164 * Why have the TLVs in LE_ARP entries 1165 * since we do not use them? When you 1166 * uncomment this code, make sure the 1167 * TLVs get freed when entry is killed 1168 */ 1169 struct lec_arp_table *entry = lec_arp_find(priv, mac_addr); 1170 1171 if (entry == NULL) 1172 return; /* should not happen */ 1173 1174 kfree(entry->tlvs); 1175 1176 entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1177 if (entry->tlvs == NULL) 1178 return; 1179 entry->sizeoftlvs = sizeoftlvs; 1180 #endif 1181 #if 0 1182 pr_info("\n"); 1183 pr_info("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs); 1184 while (i < sizeoftlvs) 1185 pr_cont("%02x ", tlvs[i++]); 1186 1187 pr_cont("\n"); 1188 #endif 1189 1190 /* tell MPOA about the TLVs we saw */ 1191 if (priv->lane2_ops && priv->lane2_ops->associate_indicator) { 1192 priv->lane2_ops->associate_indicator(dev, mac_addr, 1193 tlvs, sizeoftlvs); 1194 } 1195 } 1196 1197 /* 1198 * Here starts what used to lec_arpc.c 1199 * 1200 * lec_arpc.c was added here when making 1201 * lane client modular. October 1997 1202 */ 1203 1204 #include <linux/types.h> 1205 #include <linux/timer.h> 1206 #include <linux/param.h> 1207 #include <linux/atomic.h> 1208 #include <linux/inetdevice.h> 1209 #include <net/route.h> 1210 1211 #if 0 1212 #define pr_debug(format, args...) 1213 /* 1214 #define pr_debug printk 1215 */ 1216 #endif 1217 #define DEBUG_ARP_TABLE 0 1218 1219 #define LEC_ARP_REFRESH_INTERVAL (3*HZ) 1220 1221 static void lec_arp_check_expire(struct work_struct *work); 1222 static void lec_arp_expire_arp(struct timer_list *t); 1223 1224 /* 1225 * Arp table funcs 1226 */ 1227 1228 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE - 1)) 1229 1230 /* 1231 * Initialization of arp-cache 1232 */ 1233 static void lec_arp_init(struct lec_priv *priv) 1234 { 1235 unsigned short i; 1236 1237 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 1238 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1239 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1240 INIT_HLIST_HEAD(&priv->lec_no_forward); 1241 INIT_HLIST_HEAD(&priv->mcast_fwds); 1242 spin_lock_init(&priv->lec_arp_lock); 1243 INIT_DELAYED_WORK(&priv->lec_arp_work, lec_arp_check_expire); 1244 schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL); 1245 } 1246 1247 static void lec_arp_clear_vccs(struct lec_arp_table *entry) 1248 { 1249 if (entry->vcc) { 1250 struct atm_vcc *vcc = entry->vcc; 1251 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 1252 struct net_device *dev = (struct net_device *)vcc->proto_data; 1253 1254 vcc->pop = vpriv->old_pop; 1255 if (vpriv->xoff) 1256 netif_wake_queue(dev); 1257 kfree(vpriv); 1258 vcc->user_back = NULL; 1259 vcc->push = entry->old_push; 1260 vcc_release_async(vcc, -EPIPE); 1261 entry->vcc = NULL; 1262 } 1263 if (entry->recv_vcc) { 1264 struct atm_vcc *vcc = entry->recv_vcc; 1265 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 1266 1267 kfree(vpriv); 1268 vcc->user_back = NULL; 1269 1270 entry->recv_vcc->push = entry->old_recv_push; 1271 vcc_release_async(entry->recv_vcc, -EPIPE); 1272 entry->recv_vcc = NULL; 1273 } 1274 } 1275 1276 /* 1277 * Insert entry to lec_arp_table 1278 * LANE2: Add to the end of the list to satisfy 8.1.13 1279 */ 1280 static inline void 1281 lec_arp_add(struct lec_priv *priv, struct lec_arp_table *entry) 1282 { 1283 struct hlist_head *tmp; 1284 1285 tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])]; 1286 hlist_add_head(&entry->next, tmp); 1287 1288 pr_debug("Added entry:%pM\n", entry->mac_addr); 1289 } 1290 1291 /* 1292 * Remove entry from lec_arp_table 1293 */ 1294 static int 1295 lec_arp_remove(struct lec_priv *priv, struct lec_arp_table *to_remove) 1296 { 1297 struct lec_arp_table *entry; 1298 int i, remove_vcc = 1; 1299 1300 if (!to_remove) 1301 return -1; 1302 1303 hlist_del(&to_remove->next); 1304 del_timer(&to_remove->timer); 1305 1306 /* 1307 * If this is the only MAC connected to this VCC, 1308 * also tear down the VCC 1309 */ 1310 if (to_remove->status >= ESI_FLUSH_PENDING) { 1311 /* 1312 * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT 1313 */ 1314 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1315 hlist_for_each_entry(entry, 1316 &priv->lec_arp_tables[i], next) { 1317 if (memcmp(to_remove->atm_addr, 1318 entry->atm_addr, ATM_ESA_LEN) == 0) { 1319 remove_vcc = 0; 1320 break; 1321 } 1322 } 1323 } 1324 if (remove_vcc) 1325 lec_arp_clear_vccs(to_remove); 1326 } 1327 skb_queue_purge(&to_remove->tx_wait); /* FIXME: good place for this? */ 1328 1329 pr_debug("Removed entry:%pM\n", to_remove->mac_addr); 1330 return 0; 1331 } 1332 1333 #if DEBUG_ARP_TABLE 1334 static const char *get_status_string(unsigned char st) 1335 { 1336 switch (st) { 1337 case ESI_UNKNOWN: 1338 return "ESI_UNKNOWN"; 1339 case ESI_ARP_PENDING: 1340 return "ESI_ARP_PENDING"; 1341 case ESI_VC_PENDING: 1342 return "ESI_VC_PENDING"; 1343 case ESI_FLUSH_PENDING: 1344 return "ESI_FLUSH_PENDING"; 1345 case ESI_FORWARD_DIRECT: 1346 return "ESI_FORWARD_DIRECT"; 1347 } 1348 return "<UNKNOWN>"; 1349 } 1350 1351 static void dump_arp_table(struct lec_priv *priv) 1352 { 1353 struct lec_arp_table *rulla; 1354 char buf[256]; 1355 int i, offset; 1356 1357 pr_info("Dump %p:\n", priv); 1358 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1359 hlist_for_each_entry(rulla, 1360 &priv->lec_arp_tables[i], next) { 1361 offset = 0; 1362 offset += sprintf(buf, "%d: %p\n", i, rulla); 1363 offset += sprintf(buf + offset, "Mac: %pM ", 1364 rulla->mac_addr); 1365 offset += sprintf(buf + offset, "Atm: %*ph ", ATM_ESA_LEN, 1366 rulla->atm_addr); 1367 offset += sprintf(buf + offset, 1368 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1369 rulla->vcc ? rulla->vcc->vpi : 0, 1370 rulla->vcc ? rulla->vcc->vci : 0, 1371 rulla->recv_vcc ? rulla->recv_vcc-> 1372 vpi : 0, 1373 rulla->recv_vcc ? rulla->recv_vcc-> 1374 vci : 0, rulla->last_used, 1375 rulla->timestamp, rulla->no_tries); 1376 offset += 1377 sprintf(buf + offset, 1378 "Flags:%x, Packets_flooded:%x, Status: %s ", 1379 rulla->flags, rulla->packets_flooded, 1380 get_status_string(rulla->status)); 1381 pr_info("%s\n", buf); 1382 } 1383 } 1384 1385 if (!hlist_empty(&priv->lec_no_forward)) 1386 pr_info("No forward\n"); 1387 hlist_for_each_entry(rulla, &priv->lec_no_forward, next) { 1388 offset = 0; 1389 offset += sprintf(buf + offset, "Mac: %pM ", rulla->mac_addr); 1390 offset += sprintf(buf + offset, "Atm: %*ph ", ATM_ESA_LEN, 1391 rulla->atm_addr); 1392 offset += sprintf(buf + offset, 1393 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1394 rulla->vcc ? rulla->vcc->vpi : 0, 1395 rulla->vcc ? rulla->vcc->vci : 0, 1396 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1397 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1398 rulla->last_used, 1399 rulla->timestamp, rulla->no_tries); 1400 offset += sprintf(buf + offset, 1401 "Flags:%x, Packets_flooded:%x, Status: %s ", 1402 rulla->flags, rulla->packets_flooded, 1403 get_status_string(rulla->status)); 1404 pr_info("%s\n", buf); 1405 } 1406 1407 if (!hlist_empty(&priv->lec_arp_empty_ones)) 1408 pr_info("Empty ones\n"); 1409 hlist_for_each_entry(rulla, &priv->lec_arp_empty_ones, next) { 1410 offset = 0; 1411 offset += sprintf(buf + offset, "Mac: %pM ", rulla->mac_addr); 1412 offset += sprintf(buf + offset, "Atm: %*ph ", ATM_ESA_LEN, 1413 rulla->atm_addr); 1414 offset += sprintf(buf + offset, 1415 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1416 rulla->vcc ? rulla->vcc->vpi : 0, 1417 rulla->vcc ? rulla->vcc->vci : 0, 1418 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1419 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1420 rulla->last_used, 1421 rulla->timestamp, rulla->no_tries); 1422 offset += sprintf(buf + offset, 1423 "Flags:%x, Packets_flooded:%x, Status: %s ", 1424 rulla->flags, rulla->packets_flooded, 1425 get_status_string(rulla->status)); 1426 pr_info("%s", buf); 1427 } 1428 1429 if (!hlist_empty(&priv->mcast_fwds)) 1430 pr_info("Multicast Forward VCCs\n"); 1431 hlist_for_each_entry(rulla, &priv->mcast_fwds, next) { 1432 offset = 0; 1433 offset += sprintf(buf + offset, "Mac: %pM ", rulla->mac_addr); 1434 offset += sprintf(buf + offset, "Atm: %*ph ", ATM_ESA_LEN, 1435 rulla->atm_addr); 1436 offset += sprintf(buf + offset, 1437 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1438 rulla->vcc ? rulla->vcc->vpi : 0, 1439 rulla->vcc ? rulla->vcc->vci : 0, 1440 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1441 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1442 rulla->last_used, 1443 rulla->timestamp, rulla->no_tries); 1444 offset += sprintf(buf + offset, 1445 "Flags:%x, Packets_flooded:%x, Status: %s ", 1446 rulla->flags, rulla->packets_flooded, 1447 get_status_string(rulla->status)); 1448 pr_info("%s\n", buf); 1449 } 1450 1451 } 1452 #else 1453 #define dump_arp_table(priv) do { } while (0) 1454 #endif 1455 1456 /* 1457 * Destruction of arp-cache 1458 */ 1459 static void lec_arp_destroy(struct lec_priv *priv) 1460 { 1461 unsigned long flags; 1462 struct hlist_node *next; 1463 struct lec_arp_table *entry; 1464 int i; 1465 1466 cancel_delayed_work_sync(&priv->lec_arp_work); 1467 1468 /* 1469 * Remove all entries 1470 */ 1471 1472 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1473 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1474 hlist_for_each_entry_safe(entry, next, 1475 &priv->lec_arp_tables[i], next) { 1476 lec_arp_remove(priv, entry); 1477 lec_arp_put(entry); 1478 } 1479 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1480 } 1481 1482 hlist_for_each_entry_safe(entry, next, 1483 &priv->lec_arp_empty_ones, next) { 1484 del_timer_sync(&entry->timer); 1485 lec_arp_clear_vccs(entry); 1486 hlist_del(&entry->next); 1487 lec_arp_put(entry); 1488 } 1489 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1490 1491 hlist_for_each_entry_safe(entry, next, 1492 &priv->lec_no_forward, next) { 1493 del_timer_sync(&entry->timer); 1494 lec_arp_clear_vccs(entry); 1495 hlist_del(&entry->next); 1496 lec_arp_put(entry); 1497 } 1498 INIT_HLIST_HEAD(&priv->lec_no_forward); 1499 1500 hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) { 1501 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 1502 lec_arp_clear_vccs(entry); 1503 hlist_del(&entry->next); 1504 lec_arp_put(entry); 1505 } 1506 INIT_HLIST_HEAD(&priv->mcast_fwds); 1507 priv->mcast_vcc = NULL; 1508 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1509 } 1510 1511 /* 1512 * Find entry by mac_address 1513 */ 1514 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv, 1515 const unsigned char *mac_addr) 1516 { 1517 struct hlist_head *head; 1518 struct lec_arp_table *entry; 1519 1520 pr_debug("%pM\n", mac_addr); 1521 1522 head = &priv->lec_arp_tables[HASH(mac_addr[ETH_ALEN - 1])]; 1523 hlist_for_each_entry(entry, head, next) { 1524 if (ether_addr_equal(mac_addr, entry->mac_addr)) 1525 return entry; 1526 } 1527 return NULL; 1528 } 1529 1530 static struct lec_arp_table *make_entry(struct lec_priv *priv, 1531 const unsigned char *mac_addr) 1532 { 1533 struct lec_arp_table *to_return; 1534 1535 to_return = kzalloc(sizeof(struct lec_arp_table), GFP_ATOMIC); 1536 if (!to_return) 1537 return NULL; 1538 ether_addr_copy(to_return->mac_addr, mac_addr); 1539 INIT_HLIST_NODE(&to_return->next); 1540 timer_setup(&to_return->timer, lec_arp_expire_arp, 0); 1541 to_return->last_used = jiffies; 1542 to_return->priv = priv; 1543 skb_queue_head_init(&to_return->tx_wait); 1544 refcount_set(&to_return->usage, 1); 1545 return to_return; 1546 } 1547 1548 /* Arp sent timer expired */ 1549 static void lec_arp_expire_arp(struct timer_list *t) 1550 { 1551 struct lec_arp_table *entry; 1552 1553 entry = from_timer(entry, t, timer); 1554 1555 pr_debug("\n"); 1556 if (entry->status == ESI_ARP_PENDING) { 1557 if (entry->no_tries <= entry->priv->max_retry_count) { 1558 if (entry->is_rdesc) 1559 send_to_lecd(entry->priv, l_rdesc_arp_xmt, 1560 entry->mac_addr, NULL, NULL); 1561 else 1562 send_to_lecd(entry->priv, l_arp_xmt, 1563 entry->mac_addr, NULL, NULL); 1564 entry->no_tries++; 1565 } 1566 mod_timer(&entry->timer, jiffies + (1 * HZ)); 1567 } 1568 } 1569 1570 /* Unknown/unused vcc expire, remove associated entry */ 1571 static void lec_arp_expire_vcc(struct timer_list *t) 1572 { 1573 unsigned long flags; 1574 struct lec_arp_table *to_remove = from_timer(to_remove, t, timer); 1575 struct lec_priv *priv = to_remove->priv; 1576 1577 del_timer(&to_remove->timer); 1578 1579 pr_debug("%p %p: vpi:%d vci:%d\n", 1580 to_remove, priv, 1581 to_remove->vcc ? to_remove->recv_vcc->vpi : 0, 1582 to_remove->vcc ? to_remove->recv_vcc->vci : 0); 1583 1584 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1585 hlist_del(&to_remove->next); 1586 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1587 1588 lec_arp_clear_vccs(to_remove); 1589 lec_arp_put(to_remove); 1590 } 1591 1592 static bool __lec_arp_check_expire(struct lec_arp_table *entry, 1593 unsigned long now, 1594 struct lec_priv *priv) 1595 { 1596 unsigned long time_to_check; 1597 1598 if ((entry->flags) & LEC_REMOTE_FLAG && priv->topology_change) 1599 time_to_check = priv->forward_delay_time; 1600 else 1601 time_to_check = priv->aging_time; 1602 1603 pr_debug("About to expire: %lx - %lx > %lx\n", 1604 now, entry->last_used, time_to_check); 1605 if (time_after(now, entry->last_used + time_to_check) && 1606 !(entry->flags & LEC_PERMANENT_FLAG) && 1607 !(entry->mac_addr[0] & 0x01)) { /* LANE2: 7.1.20 */ 1608 /* Remove entry */ 1609 pr_debug("Entry timed out\n"); 1610 lec_arp_remove(priv, entry); 1611 lec_arp_put(entry); 1612 } else { 1613 /* Something else */ 1614 if ((entry->status == ESI_VC_PENDING || 1615 entry->status == ESI_ARP_PENDING) && 1616 time_after_eq(now, entry->timestamp + 1617 priv->max_unknown_frame_time)) { 1618 entry->timestamp = jiffies; 1619 entry->packets_flooded = 0; 1620 if (entry->status == ESI_VC_PENDING) 1621 send_to_lecd(priv, l_svc_setup, 1622 entry->mac_addr, 1623 entry->atm_addr, 1624 NULL); 1625 } 1626 if (entry->status == ESI_FLUSH_PENDING && 1627 time_after_eq(now, entry->timestamp + 1628 priv->path_switching_delay)) { 1629 lec_arp_hold(entry); 1630 return true; 1631 } 1632 } 1633 1634 return false; 1635 } 1636 /* 1637 * Expire entries. 1638 * 1. Re-set timer 1639 * 2. For each entry, delete entries that have aged past the age limit. 1640 * 3. For each entry, depending on the status of the entry, perform 1641 * the following maintenance. 1642 * a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the 1643 * tick_count is above the max_unknown_frame_time, clear 1644 * the tick_count to zero and clear the packets_flooded counter 1645 * to zero. This supports the packet rate limit per address 1646 * while flooding unknowns. 1647 * b. If the status is ESI_FLUSH_PENDING and the tick_count is greater 1648 * than or equal to the path_switching_delay, change the status 1649 * to ESI_FORWARD_DIRECT. This causes the flush period to end 1650 * regardless of the progress of the flush protocol. 1651 */ 1652 static void lec_arp_check_expire(struct work_struct *work) 1653 { 1654 unsigned long flags; 1655 struct lec_priv *priv = 1656 container_of(work, struct lec_priv, lec_arp_work.work); 1657 struct hlist_node *next; 1658 struct lec_arp_table *entry; 1659 unsigned long now; 1660 int i; 1661 1662 pr_debug("%p\n", priv); 1663 now = jiffies; 1664 restart: 1665 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1666 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1667 hlist_for_each_entry_safe(entry, next, 1668 &priv->lec_arp_tables[i], next) { 1669 if (__lec_arp_check_expire(entry, now, priv)) { 1670 struct sk_buff *skb; 1671 struct atm_vcc *vcc = entry->vcc; 1672 1673 spin_unlock_irqrestore(&priv->lec_arp_lock, 1674 flags); 1675 while ((skb = skb_dequeue(&entry->tx_wait))) 1676 lec_send(vcc, skb); 1677 entry->last_used = jiffies; 1678 entry->status = ESI_FORWARD_DIRECT; 1679 lec_arp_put(entry); 1680 1681 goto restart; 1682 } 1683 } 1684 } 1685 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1686 1687 schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL); 1688 } 1689 1690 /* 1691 * Try to find vcc where mac_address is attached. 1692 * 1693 */ 1694 static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv, 1695 const unsigned char *mac_to_find, 1696 int is_rdesc, 1697 struct lec_arp_table **ret_entry) 1698 { 1699 unsigned long flags; 1700 struct lec_arp_table *entry; 1701 struct atm_vcc *found; 1702 1703 if (mac_to_find[0] & 0x01) { 1704 switch (priv->lane_version) { 1705 case 1: 1706 return priv->mcast_vcc; 1707 case 2: /* LANE2 wants arp for multicast addresses */ 1708 if (ether_addr_equal(mac_to_find, bus_mac)) 1709 return priv->mcast_vcc; 1710 break; 1711 default: 1712 break; 1713 } 1714 } 1715 1716 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1717 entry = lec_arp_find(priv, mac_to_find); 1718 1719 if (entry) { 1720 if (entry->status == ESI_FORWARD_DIRECT) { 1721 /* Connection Ok */ 1722 entry->last_used = jiffies; 1723 lec_arp_hold(entry); 1724 *ret_entry = entry; 1725 found = entry->vcc; 1726 goto out; 1727 } 1728 /* 1729 * If the LE_ARP cache entry is still pending, reset count to 0 1730 * so another LE_ARP request can be made for this frame. 1731 */ 1732 if (entry->status == ESI_ARP_PENDING) 1733 entry->no_tries = 0; 1734 /* 1735 * Data direct VC not yet set up, check to see if the unknown 1736 * frame count is greater than the limit. If the limit has 1737 * not been reached, allow the caller to send packet to 1738 * BUS. 1739 */ 1740 if (entry->status != ESI_FLUSH_PENDING && 1741 entry->packets_flooded < 1742 priv->maximum_unknown_frame_count) { 1743 entry->packets_flooded++; 1744 pr_debug("Flooding..\n"); 1745 found = priv->mcast_vcc; 1746 goto out; 1747 } 1748 /* 1749 * We got here because entry->status == ESI_FLUSH_PENDING 1750 * or BUS flood limit was reached for an entry which is 1751 * in ESI_ARP_PENDING or ESI_VC_PENDING state. 1752 */ 1753 lec_arp_hold(entry); 1754 *ret_entry = entry; 1755 pr_debug("entry->status %d entry->vcc %p\n", entry->status, 1756 entry->vcc); 1757 found = NULL; 1758 } else { 1759 /* No matching entry was found */ 1760 entry = make_entry(priv, mac_to_find); 1761 pr_debug("Making entry\n"); 1762 if (!entry) { 1763 found = priv->mcast_vcc; 1764 goto out; 1765 } 1766 lec_arp_add(priv, entry); 1767 /* We want arp-request(s) to be sent */ 1768 entry->packets_flooded = 1; 1769 entry->status = ESI_ARP_PENDING; 1770 entry->no_tries = 1; 1771 entry->last_used = entry->timestamp = jiffies; 1772 entry->is_rdesc = is_rdesc; 1773 if (entry->is_rdesc) 1774 send_to_lecd(priv, l_rdesc_arp_xmt, mac_to_find, NULL, 1775 NULL); 1776 else 1777 send_to_lecd(priv, l_arp_xmt, mac_to_find, NULL, NULL); 1778 entry->timer.expires = jiffies + (1 * HZ); 1779 entry->timer.function = lec_arp_expire_arp; 1780 add_timer(&entry->timer); 1781 found = priv->mcast_vcc; 1782 } 1783 1784 out: 1785 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1786 return found; 1787 } 1788 1789 static int 1790 lec_addr_delete(struct lec_priv *priv, const unsigned char *atm_addr, 1791 unsigned long permanent) 1792 { 1793 unsigned long flags; 1794 struct hlist_node *next; 1795 struct lec_arp_table *entry; 1796 int i; 1797 1798 pr_debug("\n"); 1799 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1800 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1801 hlist_for_each_entry_safe(entry, next, 1802 &priv->lec_arp_tables[i], next) { 1803 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN) && 1804 (permanent || 1805 !(entry->flags & LEC_PERMANENT_FLAG))) { 1806 lec_arp_remove(priv, entry); 1807 lec_arp_put(entry); 1808 } 1809 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1810 return 0; 1811 } 1812 } 1813 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1814 return -1; 1815 } 1816 1817 /* 1818 * Notifies: Response to arp_request (atm_addr != NULL) 1819 */ 1820 static void 1821 lec_arp_update(struct lec_priv *priv, const unsigned char *mac_addr, 1822 const unsigned char *atm_addr, unsigned long remoteflag, 1823 unsigned int targetless_le_arp) 1824 { 1825 unsigned long flags; 1826 struct hlist_node *next; 1827 struct lec_arp_table *entry, *tmp; 1828 int i; 1829 1830 pr_debug("%smac:%pM\n", 1831 (targetless_le_arp) ? "targetless " : "", mac_addr); 1832 1833 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1834 entry = lec_arp_find(priv, mac_addr); 1835 if (entry == NULL && targetless_le_arp) 1836 goto out; /* 1837 * LANE2: ignore targetless LE_ARPs for which 1838 * we have no entry in the cache. 7.1.30 1839 */ 1840 if (!hlist_empty(&priv->lec_arp_empty_ones)) { 1841 hlist_for_each_entry_safe(entry, next, 1842 &priv->lec_arp_empty_ones, next) { 1843 if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) { 1844 hlist_del(&entry->next); 1845 del_timer(&entry->timer); 1846 tmp = lec_arp_find(priv, mac_addr); 1847 if (tmp) { 1848 del_timer(&tmp->timer); 1849 tmp->status = ESI_FORWARD_DIRECT; 1850 memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN); 1851 tmp->vcc = entry->vcc; 1852 tmp->old_push = entry->old_push; 1853 tmp->last_used = jiffies; 1854 del_timer(&entry->timer); 1855 lec_arp_put(entry); 1856 entry = tmp; 1857 } else { 1858 entry->status = ESI_FORWARD_DIRECT; 1859 ether_addr_copy(entry->mac_addr, 1860 mac_addr); 1861 entry->last_used = jiffies; 1862 lec_arp_add(priv, entry); 1863 } 1864 if (remoteflag) 1865 entry->flags |= LEC_REMOTE_FLAG; 1866 else 1867 entry->flags &= ~LEC_REMOTE_FLAG; 1868 pr_debug("After update\n"); 1869 dump_arp_table(priv); 1870 goto out; 1871 } 1872 } 1873 } 1874 1875 entry = lec_arp_find(priv, mac_addr); 1876 if (!entry) { 1877 entry = make_entry(priv, mac_addr); 1878 if (!entry) 1879 goto out; 1880 entry->status = ESI_UNKNOWN; 1881 lec_arp_add(priv, entry); 1882 /* Temporary, changes before end of function */ 1883 } 1884 memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN); 1885 del_timer(&entry->timer); 1886 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1887 hlist_for_each_entry(tmp, 1888 &priv->lec_arp_tables[i], next) { 1889 if (entry != tmp && 1890 !memcmp(tmp->atm_addr, atm_addr, ATM_ESA_LEN)) { 1891 /* Vcc to this host exists */ 1892 if (tmp->status > ESI_VC_PENDING) { 1893 /* 1894 * ESI_FLUSH_PENDING, 1895 * ESI_FORWARD_DIRECT 1896 */ 1897 entry->vcc = tmp->vcc; 1898 entry->old_push = tmp->old_push; 1899 } 1900 entry->status = tmp->status; 1901 break; 1902 } 1903 } 1904 } 1905 if (remoteflag) 1906 entry->flags |= LEC_REMOTE_FLAG; 1907 else 1908 entry->flags &= ~LEC_REMOTE_FLAG; 1909 if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) { 1910 entry->status = ESI_VC_PENDING; 1911 send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL); 1912 } 1913 pr_debug("After update2\n"); 1914 dump_arp_table(priv); 1915 out: 1916 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1917 } 1918 1919 /* 1920 * Notifies: Vcc setup ready 1921 */ 1922 static void 1923 lec_vcc_added(struct lec_priv *priv, const struct atmlec_ioc *ioc_data, 1924 struct atm_vcc *vcc, 1925 void (*old_push) (struct atm_vcc *vcc, struct sk_buff *skb)) 1926 { 1927 unsigned long flags; 1928 struct lec_arp_table *entry; 1929 int i, found_entry = 0; 1930 1931 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1932 /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */ 1933 if (ioc_data->receive == 2) { 1934 pr_debug("LEC_ARP: Attaching mcast forward\n"); 1935 #if 0 1936 entry = lec_arp_find(priv, bus_mac); 1937 if (!entry) { 1938 pr_info("LEC_ARP: Multicast entry not found!\n"); 1939 goto out; 1940 } 1941 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1942 entry->recv_vcc = vcc; 1943 entry->old_recv_push = old_push; 1944 #endif 1945 entry = make_entry(priv, bus_mac); 1946 if (entry == NULL) 1947 goto out; 1948 del_timer(&entry->timer); 1949 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1950 entry->recv_vcc = vcc; 1951 entry->old_recv_push = old_push; 1952 hlist_add_head(&entry->next, &priv->mcast_fwds); 1953 goto out; 1954 } else if (ioc_data->receive == 1) { 1955 /* 1956 * Vcc which we don't want to make default vcc, 1957 * attach it anyway. 1958 */ 1959 pr_debug("LEC_ARP:Attaching data direct, not default: %*phN\n", 1960 ATM_ESA_LEN, ioc_data->atm_addr); 1961 entry = make_entry(priv, bus_mac); 1962 if (entry == NULL) 1963 goto out; 1964 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1965 eth_zero_addr(entry->mac_addr); 1966 entry->recv_vcc = vcc; 1967 entry->old_recv_push = old_push; 1968 entry->status = ESI_UNKNOWN; 1969 entry->timer.expires = jiffies + priv->vcc_timeout_period; 1970 entry->timer.function = lec_arp_expire_vcc; 1971 hlist_add_head(&entry->next, &priv->lec_no_forward); 1972 add_timer(&entry->timer); 1973 dump_arp_table(priv); 1974 goto out; 1975 } 1976 pr_debug("LEC_ARP:Attaching data direct, default: %*phN\n", 1977 ATM_ESA_LEN, ioc_data->atm_addr); 1978 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1979 hlist_for_each_entry(entry, 1980 &priv->lec_arp_tables[i], next) { 1981 if (memcmp 1982 (ioc_data->atm_addr, entry->atm_addr, 1983 ATM_ESA_LEN) == 0) { 1984 pr_debug("LEC_ARP: Attaching data direct\n"); 1985 pr_debug("Currently -> Vcc: %d, Rvcc:%d\n", 1986 entry->vcc ? entry->vcc->vci : 0, 1987 entry->recv_vcc ? entry->recv_vcc-> 1988 vci : 0); 1989 found_entry = 1; 1990 del_timer(&entry->timer); 1991 entry->vcc = vcc; 1992 entry->old_push = old_push; 1993 if (entry->status == ESI_VC_PENDING) { 1994 if (priv->maximum_unknown_frame_count 1995 == 0) 1996 entry->status = 1997 ESI_FORWARD_DIRECT; 1998 else { 1999 entry->timestamp = jiffies; 2000 entry->status = 2001 ESI_FLUSH_PENDING; 2002 #if 0 2003 send_to_lecd(priv, l_flush_xmt, 2004 NULL, 2005 entry->atm_addr, 2006 NULL); 2007 #endif 2008 } 2009 } else { 2010 /* 2011 * They were forming a connection 2012 * to us, and we to them. Our 2013 * ATM address is numerically lower 2014 * than theirs, so we make connection 2015 * we formed into default VCC (8.1.11). 2016 * Connection they made gets torn 2017 * down. This might confuse some 2018 * clients. Can be changed if 2019 * someone reports trouble... 2020 */ 2021 ; 2022 } 2023 } 2024 } 2025 } 2026 if (found_entry) { 2027 pr_debug("After vcc was added\n"); 2028 dump_arp_table(priv); 2029 goto out; 2030 } 2031 /* 2032 * Not found, snatch address from first data packet that arrives 2033 * from this vcc 2034 */ 2035 entry = make_entry(priv, bus_mac); 2036 if (!entry) 2037 goto out; 2038 entry->vcc = vcc; 2039 entry->old_push = old_push; 2040 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 2041 eth_zero_addr(entry->mac_addr); 2042 entry->status = ESI_UNKNOWN; 2043 hlist_add_head(&entry->next, &priv->lec_arp_empty_ones); 2044 entry->timer.expires = jiffies + priv->vcc_timeout_period; 2045 entry->timer.function = lec_arp_expire_vcc; 2046 add_timer(&entry->timer); 2047 pr_debug("After vcc was added\n"); 2048 dump_arp_table(priv); 2049 out: 2050 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2051 } 2052 2053 static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id) 2054 { 2055 unsigned long flags; 2056 struct lec_arp_table *entry; 2057 int i; 2058 2059 pr_debug("%lx\n", tran_id); 2060 restart: 2061 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2062 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2063 hlist_for_each_entry(entry, 2064 &priv->lec_arp_tables[i], next) { 2065 if (entry->flush_tran_id == tran_id && 2066 entry->status == ESI_FLUSH_PENDING) { 2067 struct sk_buff *skb; 2068 struct atm_vcc *vcc = entry->vcc; 2069 2070 lec_arp_hold(entry); 2071 spin_unlock_irqrestore(&priv->lec_arp_lock, 2072 flags); 2073 while ((skb = skb_dequeue(&entry->tx_wait))) 2074 lec_send(vcc, skb); 2075 entry->last_used = jiffies; 2076 entry->status = ESI_FORWARD_DIRECT; 2077 lec_arp_put(entry); 2078 pr_debug("LEC_ARP: Flushed\n"); 2079 goto restart; 2080 } 2081 } 2082 } 2083 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2084 dump_arp_table(priv); 2085 } 2086 2087 static void 2088 lec_set_flush_tran_id(struct lec_priv *priv, 2089 const unsigned char *atm_addr, unsigned long tran_id) 2090 { 2091 unsigned long flags; 2092 struct lec_arp_table *entry; 2093 int i; 2094 2095 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2096 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 2097 hlist_for_each_entry(entry, 2098 &priv->lec_arp_tables[i], next) { 2099 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) { 2100 entry->flush_tran_id = tran_id; 2101 pr_debug("Set flush transaction id to %lx for %p\n", 2102 tran_id, entry); 2103 } 2104 } 2105 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2106 } 2107 2108 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc) 2109 { 2110 unsigned long flags; 2111 unsigned char mac_addr[] = { 2112 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2113 }; 2114 struct lec_arp_table *to_add; 2115 struct lec_vcc_priv *vpriv; 2116 int err = 0; 2117 2118 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 2119 if (!vpriv) 2120 return -ENOMEM; 2121 vpriv->xoff = 0; 2122 vpriv->old_pop = vcc->pop; 2123 vcc->user_back = vpriv; 2124 vcc->pop = lec_pop; 2125 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2126 to_add = make_entry(priv, mac_addr); 2127 if (!to_add) { 2128 vcc->pop = vpriv->old_pop; 2129 kfree(vpriv); 2130 err = -ENOMEM; 2131 goto out; 2132 } 2133 memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN); 2134 to_add->status = ESI_FORWARD_DIRECT; 2135 to_add->flags |= LEC_PERMANENT_FLAG; 2136 to_add->vcc = vcc; 2137 to_add->old_push = vcc->push; 2138 vcc->push = lec_push; 2139 priv->mcast_vcc = vcc; 2140 lec_arp_add(priv, to_add); 2141 out: 2142 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2143 return err; 2144 } 2145 2146 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc) 2147 { 2148 unsigned long flags; 2149 struct hlist_node *next; 2150 struct lec_arp_table *entry; 2151 int i; 2152 2153 pr_debug("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc->vpi, vcc->vci); 2154 dump_arp_table(priv); 2155 2156 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2157 2158 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2159 hlist_for_each_entry_safe(entry, next, 2160 &priv->lec_arp_tables[i], next) { 2161 if (vcc == entry->vcc) { 2162 lec_arp_remove(priv, entry); 2163 lec_arp_put(entry); 2164 if (priv->mcast_vcc == vcc) 2165 priv->mcast_vcc = NULL; 2166 } 2167 } 2168 } 2169 2170 hlist_for_each_entry_safe(entry, next, 2171 &priv->lec_arp_empty_ones, next) { 2172 if (entry->vcc == vcc) { 2173 lec_arp_clear_vccs(entry); 2174 del_timer(&entry->timer); 2175 hlist_del(&entry->next); 2176 lec_arp_put(entry); 2177 } 2178 } 2179 2180 hlist_for_each_entry_safe(entry, next, 2181 &priv->lec_no_forward, next) { 2182 if (entry->recv_vcc == vcc) { 2183 lec_arp_clear_vccs(entry); 2184 del_timer(&entry->timer); 2185 hlist_del(&entry->next); 2186 lec_arp_put(entry); 2187 } 2188 } 2189 2190 hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) { 2191 if (entry->recv_vcc == vcc) { 2192 lec_arp_clear_vccs(entry); 2193 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 2194 hlist_del(&entry->next); 2195 lec_arp_put(entry); 2196 } 2197 } 2198 2199 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2200 dump_arp_table(priv); 2201 } 2202 2203 static void 2204 lec_arp_check_empties(struct lec_priv *priv, 2205 struct atm_vcc *vcc, struct sk_buff *skb) 2206 { 2207 unsigned long flags; 2208 struct hlist_node *next; 2209 struct lec_arp_table *entry, *tmp; 2210 struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data; 2211 unsigned char *src = hdr->h_source; 2212 2213 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2214 hlist_for_each_entry_safe(entry, next, 2215 &priv->lec_arp_empty_ones, next) { 2216 if (vcc == entry->vcc) { 2217 del_timer(&entry->timer); 2218 ether_addr_copy(entry->mac_addr, src); 2219 entry->status = ESI_FORWARD_DIRECT; 2220 entry->last_used = jiffies; 2221 /* We might have got an entry */ 2222 tmp = lec_arp_find(priv, src); 2223 if (tmp) { 2224 lec_arp_remove(priv, tmp); 2225 lec_arp_put(tmp); 2226 } 2227 hlist_del(&entry->next); 2228 lec_arp_add(priv, entry); 2229 goto out; 2230 } 2231 } 2232 pr_debug("LEC_ARP: Arp_check_empties: entry not found!\n"); 2233 out: 2234 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2235 } 2236 2237 MODULE_DESCRIPTION("ATM LAN Emulation (LANE) support"); 2238 MODULE_LICENSE("GPL"); 2239