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