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 IS_ENABLED(CONFIG_BRIDGE) 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 refcount_inc(&entry->usage); 105 } 106 107 static inline void lec_arp_put(struct lec_arp_table *entry) 108 { 109 if (refcount_dec_and_test(&entry->usage)) 110 kfree(entry); 111 } 112 113 static struct lane2_ops lane2_ops = { 114 .resolve = lane2_resolve, /* spec 3.1.3 */ 115 .associate_req = lane2_associate_req, /* spec 3.1.4 */ 116 .associate_indicator = NULL /* 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 IS_ENABLED(CONFIG_BRIDGE) 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 /* IS_ENABLED(CONFIG_BRIDGE) */ 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 refcount_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 netif_trans_update(dev); 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 IS_ENABLED(CONFIG_BRIDGE) 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 netif_trans_update(dev); 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 WARN_ON(refcount_sub_and_test(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 IS_ENABLED(CONFIG_BRIDGE) 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 /* IS_ENABLED(CONFIG_BRIDGE) */ 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 const 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 static void lec_set_multicast_list(struct net_device *dev) 548 { 549 /* 550 * by default, all multicast frames arrive over the bus. 551 * eventually support selective multicast service 552 */ 553 } 554 555 static const struct net_device_ops lec_netdev_ops = { 556 .ndo_open = lec_open, 557 .ndo_stop = lec_close, 558 .ndo_start_xmit = lec_start_xmit, 559 .ndo_tx_timeout = lec_tx_timeout, 560 .ndo_set_rx_mode = lec_set_multicast_list, 561 }; 562 563 static const unsigned char lec_ctrl_magic[] = { 564 0xff, 565 0x00, 566 0x01, 567 0x01 568 }; 569 570 #define LEC_DATA_DIRECT_8023 2 571 #define LEC_DATA_DIRECT_8025 3 572 573 static int lec_is_data_direct(struct atm_vcc *vcc) 574 { 575 return ((vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8023) || 576 (vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8025)); 577 } 578 579 static void lec_push(struct atm_vcc *vcc, struct sk_buff *skb) 580 { 581 unsigned long flags; 582 struct net_device *dev = (struct net_device *)vcc->proto_data; 583 struct lec_priv *priv = netdev_priv(dev); 584 585 #if DUMP_PACKETS > 0 586 printk(KERN_DEBUG "%s: vcc vpi:%d vci:%d\n", 587 dev->name, vcc->vpi, vcc->vci); 588 #endif 589 if (!skb) { 590 pr_debug("%s: null skb\n", dev->name); 591 lec_vcc_close(priv, vcc); 592 return; 593 } 594 #if DUMP_PACKETS >= 2 595 #define MAX_SKB_DUMP 99 596 #elif DUMP_PACKETS >= 1 597 #define MAX_SKB_DUMP 30 598 #endif 599 #if DUMP_PACKETS > 0 600 printk(KERN_DEBUG "%s: rcv datalen:%ld lecid:%4.4x\n", 601 dev->name, skb->len, priv->lecid); 602 print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1, 603 skb->data, min(MAX_SKB_DUMP, skb->len), true); 604 #endif /* DUMP_PACKETS > 0 */ 605 if (memcmp(skb->data, lec_ctrl_magic, 4) == 0) { 606 /* Control frame, to daemon */ 607 struct sock *sk = sk_atm(vcc); 608 609 pr_debug("%s: To daemon\n", dev->name); 610 skb_queue_tail(&sk->sk_receive_queue, skb); 611 sk->sk_data_ready(sk); 612 } else { /* Data frame, queue to protocol handlers */ 613 struct lec_arp_table *entry; 614 unsigned char *src, *dst; 615 616 atm_return(vcc, skb->truesize); 617 if (*(__be16 *) skb->data == htons(priv->lecid) || 618 !priv->lecd || !(dev->flags & IFF_UP)) { 619 /* 620 * Probably looping back, or if lecd is missing, 621 * lecd has gone down 622 */ 623 pr_debug("Ignoring frame...\n"); 624 dev_kfree_skb(skb); 625 return; 626 } 627 dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest; 628 629 /* 630 * If this is a Data Direct VCC, and the VCC does not match 631 * the LE_ARP cache entry, delete the LE_ARP cache entry. 632 */ 633 spin_lock_irqsave(&priv->lec_arp_lock, flags); 634 if (lec_is_data_direct(vcc)) { 635 src = ((struct lecdatahdr_8023 *)skb->data)->h_source; 636 entry = lec_arp_find(priv, src); 637 if (entry && entry->vcc != vcc) { 638 lec_arp_remove(priv, entry); 639 lec_arp_put(entry); 640 } 641 } 642 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 643 644 if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */ 645 !priv->is_proxy && /* Proxy wants all the packets */ 646 memcmp(dst, dev->dev_addr, dev->addr_len)) { 647 dev_kfree_skb(skb); 648 return; 649 } 650 if (!hlist_empty(&priv->lec_arp_empty_ones)) 651 lec_arp_check_empties(priv, vcc, skb); 652 skb_pull(skb, 2); /* skip lec_id */ 653 skb->protocol = eth_type_trans(skb, dev); 654 dev->stats.rx_packets++; 655 dev->stats.rx_bytes += skb->len; 656 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data)); 657 netif_rx(skb); 658 } 659 } 660 661 static void lec_pop(struct atm_vcc *vcc, struct sk_buff *skb) 662 { 663 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 664 struct net_device *dev = skb->dev; 665 666 if (vpriv == NULL) { 667 pr_info("vpriv = NULL!?!?!?\n"); 668 return; 669 } 670 671 vpriv->old_pop(vcc, skb); 672 673 if (vpriv->xoff && atm_may_send(vcc, 0)) { 674 vpriv->xoff = 0; 675 if (netif_running(dev) && netif_queue_stopped(dev)) 676 netif_wake_queue(dev); 677 } 678 } 679 680 static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg) 681 { 682 struct lec_vcc_priv *vpriv; 683 int bytes_left; 684 struct atmlec_ioc ioc_data; 685 686 /* Lecd must be up in this case */ 687 bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc)); 688 if (bytes_left != 0) 689 pr_info("copy from user failed for %d bytes\n", bytes_left); 690 if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF || 691 !dev_lec[ioc_data.dev_num]) 692 return -EINVAL; 693 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 694 if (!vpriv) 695 return -ENOMEM; 696 vpriv->xoff = 0; 697 vpriv->old_pop = vcc->pop; 698 vcc->user_back = vpriv; 699 vcc->pop = lec_pop; 700 lec_vcc_added(netdev_priv(dev_lec[ioc_data.dev_num]), 701 &ioc_data, vcc, vcc->push); 702 vcc->proto_data = dev_lec[ioc_data.dev_num]; 703 vcc->push = lec_push; 704 return 0; 705 } 706 707 static int lec_mcast_attach(struct atm_vcc *vcc, int arg) 708 { 709 if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg]) 710 return -EINVAL; 711 vcc->proto_data = dev_lec[arg]; 712 return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc); 713 } 714 715 /* Initialize device. */ 716 static int lecd_attach(struct atm_vcc *vcc, int arg) 717 { 718 int i; 719 struct lec_priv *priv; 720 721 if (arg < 0) 722 i = 0; 723 else 724 i = arg; 725 if (arg >= MAX_LEC_ITF) 726 return -EINVAL; 727 if (!dev_lec[i]) { 728 int size; 729 730 size = sizeof(struct lec_priv); 731 dev_lec[i] = alloc_etherdev(size); 732 if (!dev_lec[i]) 733 return -ENOMEM; 734 dev_lec[i]->netdev_ops = &lec_netdev_ops; 735 dev_lec[i]->max_mtu = 18190; 736 snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i); 737 if (register_netdev(dev_lec[i])) { 738 free_netdev(dev_lec[i]); 739 return -EINVAL; 740 } 741 742 priv = netdev_priv(dev_lec[i]); 743 } else { 744 priv = netdev_priv(dev_lec[i]); 745 if (priv->lecd) 746 return -EADDRINUSE; 747 } 748 lec_arp_init(priv); 749 priv->itfnum = i; /* LANE2 addition */ 750 priv->lecd = vcc; 751 vcc->dev = &lecatm_dev; 752 vcc_insert_socket(sk_atm(vcc)); 753 754 vcc->proto_data = dev_lec[i]; 755 set_bit(ATM_VF_META, &vcc->flags); 756 set_bit(ATM_VF_READY, &vcc->flags); 757 758 /* Set default values to these variables */ 759 priv->maximum_unknown_frame_count = 1; 760 priv->max_unknown_frame_time = (1 * HZ); 761 priv->vcc_timeout_period = (1200 * HZ); 762 priv->max_retry_count = 1; 763 priv->aging_time = (300 * HZ); 764 priv->forward_delay_time = (15 * HZ); 765 priv->topology_change = 0; 766 priv->arp_response_time = (1 * HZ); 767 priv->flush_timeout = (4 * HZ); 768 priv->path_switching_delay = (6 * HZ); 769 770 if (dev_lec[i]->flags & IFF_UP) 771 netif_start_queue(dev_lec[i]); 772 __module_get(THIS_MODULE); 773 return i; 774 } 775 776 #ifdef CONFIG_PROC_FS 777 static const char *lec_arp_get_status_string(unsigned char status) 778 { 779 static const char *const lec_arp_status_string[] = { 780 "ESI_UNKNOWN ", 781 "ESI_ARP_PENDING ", 782 "ESI_VC_PENDING ", 783 "<Undefined> ", 784 "ESI_FLUSH_PENDING ", 785 "ESI_FORWARD_DIRECT" 786 }; 787 788 if (status > ESI_FORWARD_DIRECT) 789 status = 3; /* ESI_UNDEFINED */ 790 return lec_arp_status_string[status]; 791 } 792 793 static void lec_info(struct seq_file *seq, struct lec_arp_table *entry) 794 { 795 int i; 796 797 for (i = 0; i < ETH_ALEN; i++) 798 seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff); 799 seq_printf(seq, " "); 800 for (i = 0; i < ATM_ESA_LEN; i++) 801 seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff); 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 v = lec_get_idx(state, 1); 956 *pos += !!PTR_ERR(v); 957 return v; 958 } 959 960 static int lec_seq_show(struct seq_file *seq, void *v) 961 { 962 static const char lec_banner[] = 963 "Itf MAC ATM destination" 964 " Status Flags " 965 "VPI/VCI Recv VPI/VCI\n"; 966 967 if (v == SEQ_START_TOKEN) 968 seq_puts(seq, lec_banner); 969 else { 970 struct lec_state *state = seq->private; 971 struct net_device *dev = state->dev; 972 struct lec_arp_table *entry = hlist_entry(state->node, 973 struct lec_arp_table, 974 next); 975 976 seq_printf(seq, "%s ", dev->name); 977 lec_info(seq, entry); 978 } 979 return 0; 980 } 981 982 static const struct seq_operations lec_seq_ops = { 983 .start = lec_seq_start, 984 .next = lec_seq_next, 985 .stop = lec_seq_stop, 986 .show = lec_seq_show, 987 }; 988 989 static int lec_seq_open(struct inode *inode, struct file *file) 990 { 991 return seq_open_private(file, &lec_seq_ops, sizeof(struct lec_state)); 992 } 993 994 static const struct file_operations lec_seq_fops = { 995 .owner = THIS_MODULE, 996 .open = lec_seq_open, 997 .read = seq_read, 998 .llseek = seq_lseek, 999 .release = seq_release_private, 1000 }; 1001 #endif 1002 1003 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1004 { 1005 struct atm_vcc *vcc = ATM_SD(sock); 1006 int err = 0; 1007 1008 switch (cmd) { 1009 case ATMLEC_CTRL: 1010 case ATMLEC_MCAST: 1011 case ATMLEC_DATA: 1012 if (!capable(CAP_NET_ADMIN)) 1013 return -EPERM; 1014 break; 1015 default: 1016 return -ENOIOCTLCMD; 1017 } 1018 1019 switch (cmd) { 1020 case ATMLEC_CTRL: 1021 err = lecd_attach(vcc, (int)arg); 1022 if (err >= 0) 1023 sock->state = SS_CONNECTED; 1024 break; 1025 case ATMLEC_MCAST: 1026 err = lec_mcast_attach(vcc, (int)arg); 1027 break; 1028 case ATMLEC_DATA: 1029 err = lec_vcc_attach(vcc, (void __user *)arg); 1030 break; 1031 } 1032 1033 return err; 1034 } 1035 1036 static struct atm_ioctl lane_ioctl_ops = { 1037 .owner = THIS_MODULE, 1038 .ioctl = lane_ioctl, 1039 }; 1040 1041 static int __init lane_module_init(void) 1042 { 1043 #ifdef CONFIG_PROC_FS 1044 struct proc_dir_entry *p; 1045 1046 p = proc_create("lec", S_IRUGO, atm_proc_root, &lec_seq_fops); 1047 if (!p) { 1048 pr_err("Unable to initialize /proc/net/atm/lec\n"); 1049 return -ENOMEM; 1050 } 1051 #endif 1052 1053 register_atm_ioctl(&lane_ioctl_ops); 1054 pr_info("lec.c: initialized\n"); 1055 return 0; 1056 } 1057 1058 static void __exit lane_module_cleanup(void) 1059 { 1060 int i; 1061 1062 #ifdef CONFIG_PROC_FS 1063 remove_proc_entry("lec", atm_proc_root); 1064 #endif 1065 1066 deregister_atm_ioctl(&lane_ioctl_ops); 1067 1068 for (i = 0; i < MAX_LEC_ITF; i++) { 1069 if (dev_lec[i] != NULL) { 1070 unregister_netdev(dev_lec[i]); 1071 free_netdev(dev_lec[i]); 1072 dev_lec[i] = NULL; 1073 } 1074 } 1075 } 1076 1077 module_init(lane_module_init); 1078 module_exit(lane_module_cleanup); 1079 1080 /* 1081 * LANE2: 3.1.3, LE_RESOLVE.request 1082 * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs. 1083 * If sizeoftlvs == NULL the default TLVs associated with with this 1084 * lec will be used. 1085 * If dst_mac == NULL, targetless LE_ARP will be sent 1086 */ 1087 static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force, 1088 u8 **tlvs, u32 *sizeoftlvs) 1089 { 1090 unsigned long flags; 1091 struct lec_priv *priv = netdev_priv(dev); 1092 struct lec_arp_table *table; 1093 struct sk_buff *skb; 1094 int retval; 1095 1096 if (force == 0) { 1097 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1098 table = lec_arp_find(priv, dst_mac); 1099 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1100 if (table == NULL) 1101 return -1; 1102 1103 *tlvs = kmemdup(table->tlvs, table->sizeoftlvs, GFP_ATOMIC); 1104 if (*tlvs == NULL) 1105 return -1; 1106 1107 *sizeoftlvs = table->sizeoftlvs; 1108 1109 return 0; 1110 } 1111 1112 if (sizeoftlvs == NULL) 1113 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL); 1114 1115 else { 1116 skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC); 1117 if (skb == NULL) 1118 return -1; 1119 skb->len = *sizeoftlvs; 1120 skb_copy_to_linear_data(skb, *tlvs, *sizeoftlvs); 1121 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb); 1122 } 1123 return retval; 1124 } 1125 1126 /* 1127 * LANE2: 3.1.4, LE_ASSOCIATE.request 1128 * Associate the *tlvs with the *lan_dst address. 1129 * Will overwrite any previous association 1130 * Returns 1 for success, 0 for failure (out of memory) 1131 * 1132 */ 1133 static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst, 1134 const u8 *tlvs, u32 sizeoftlvs) 1135 { 1136 int retval; 1137 struct sk_buff *skb; 1138 struct lec_priv *priv = netdev_priv(dev); 1139 1140 if (!ether_addr_equal(lan_dst, dev->dev_addr)) 1141 return 0; /* not our mac address */ 1142 1143 kfree(priv->tlvs); /* NULL if there was no previous association */ 1144 1145 priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1146 if (priv->tlvs == NULL) 1147 return 0; 1148 priv->sizeoftlvs = sizeoftlvs; 1149 1150 skb = alloc_skb(sizeoftlvs, GFP_ATOMIC); 1151 if (skb == NULL) 1152 return 0; 1153 skb->len = sizeoftlvs; 1154 skb_copy_to_linear_data(skb, tlvs, sizeoftlvs); 1155 retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb); 1156 if (retval != 0) 1157 pr_info("lec.c: lane2_associate_req() failed\n"); 1158 /* 1159 * If the previous association has changed we must 1160 * somehow notify other LANE entities about the change 1161 */ 1162 return 1; 1163 } 1164 1165 /* 1166 * LANE2: 3.1.5, LE_ASSOCIATE.indication 1167 * 1168 */ 1169 static void lane2_associate_ind(struct net_device *dev, const u8 *mac_addr, 1170 const u8 *tlvs, u32 sizeoftlvs) 1171 { 1172 #if 0 1173 int i = 0; 1174 #endif 1175 struct lec_priv *priv = netdev_priv(dev); 1176 #if 0 /* 1177 * Why have the TLVs in LE_ARP entries 1178 * since we do not use them? When you 1179 * uncomment this code, make sure the 1180 * TLVs get freed when entry is killed 1181 */ 1182 struct lec_arp_table *entry = lec_arp_find(priv, mac_addr); 1183 1184 if (entry == NULL) 1185 return; /* should not happen */ 1186 1187 kfree(entry->tlvs); 1188 1189 entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1190 if (entry->tlvs == NULL) 1191 return; 1192 entry->sizeoftlvs = sizeoftlvs; 1193 #endif 1194 #if 0 1195 pr_info("\n"); 1196 pr_info("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs); 1197 while (i < sizeoftlvs) 1198 pr_cont("%02x ", tlvs[i++]); 1199 1200 pr_cont("\n"); 1201 #endif 1202 1203 /* tell MPOA about the TLVs we saw */ 1204 if (priv->lane2_ops && priv->lane2_ops->associate_indicator) { 1205 priv->lane2_ops->associate_indicator(dev, mac_addr, 1206 tlvs, sizeoftlvs); 1207 } 1208 } 1209 1210 /* 1211 * Here starts what used to lec_arpc.c 1212 * 1213 * lec_arpc.c was added here when making 1214 * lane client modular. October 1997 1215 */ 1216 1217 #include <linux/types.h> 1218 #include <linux/timer.h> 1219 #include <linux/param.h> 1220 #include <linux/atomic.h> 1221 #include <linux/inetdevice.h> 1222 #include <net/route.h> 1223 1224 #if 0 1225 #define pr_debug(format, args...) 1226 /* 1227 #define pr_debug printk 1228 */ 1229 #endif 1230 #define DEBUG_ARP_TABLE 0 1231 1232 #define LEC_ARP_REFRESH_INTERVAL (3*HZ) 1233 1234 static void lec_arp_check_expire(struct work_struct *work); 1235 static void lec_arp_expire_arp(unsigned long data); 1236 1237 /* 1238 * Arp table funcs 1239 */ 1240 1241 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE - 1)) 1242 1243 /* 1244 * Initialization of arp-cache 1245 */ 1246 static void lec_arp_init(struct lec_priv *priv) 1247 { 1248 unsigned short i; 1249 1250 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 1251 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1252 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1253 INIT_HLIST_HEAD(&priv->lec_no_forward); 1254 INIT_HLIST_HEAD(&priv->mcast_fwds); 1255 spin_lock_init(&priv->lec_arp_lock); 1256 INIT_DELAYED_WORK(&priv->lec_arp_work, lec_arp_check_expire); 1257 schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL); 1258 } 1259 1260 static void lec_arp_clear_vccs(struct lec_arp_table *entry) 1261 { 1262 if (entry->vcc) { 1263 struct atm_vcc *vcc = entry->vcc; 1264 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 1265 struct net_device *dev = (struct net_device *)vcc->proto_data; 1266 1267 vcc->pop = vpriv->old_pop; 1268 if (vpriv->xoff) 1269 netif_wake_queue(dev); 1270 kfree(vpriv); 1271 vcc->user_back = NULL; 1272 vcc->push = entry->old_push; 1273 vcc_release_async(vcc, -EPIPE); 1274 entry->vcc = NULL; 1275 } 1276 if (entry->recv_vcc) { 1277 entry->recv_vcc->push = entry->old_recv_push; 1278 vcc_release_async(entry->recv_vcc, -EPIPE); 1279 entry->recv_vcc = NULL; 1280 } 1281 } 1282 1283 /* 1284 * Insert entry to lec_arp_table 1285 * LANE2: Add to the end of the list to satisfy 8.1.13 1286 */ 1287 static inline void 1288 lec_arp_add(struct lec_priv *priv, struct lec_arp_table *entry) 1289 { 1290 struct hlist_head *tmp; 1291 1292 tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])]; 1293 hlist_add_head(&entry->next, tmp); 1294 1295 pr_debug("Added entry:%pM\n", entry->mac_addr); 1296 } 1297 1298 /* 1299 * Remove entry from lec_arp_table 1300 */ 1301 static int 1302 lec_arp_remove(struct lec_priv *priv, struct lec_arp_table *to_remove) 1303 { 1304 struct lec_arp_table *entry; 1305 int i, remove_vcc = 1; 1306 1307 if (!to_remove) 1308 return -1; 1309 1310 hlist_del(&to_remove->next); 1311 del_timer(&to_remove->timer); 1312 1313 /* 1314 * If this is the only MAC connected to this VCC, 1315 * also tear down the VCC 1316 */ 1317 if (to_remove->status >= ESI_FLUSH_PENDING) { 1318 /* 1319 * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT 1320 */ 1321 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1322 hlist_for_each_entry(entry, 1323 &priv->lec_arp_tables[i], next) { 1324 if (memcmp(to_remove->atm_addr, 1325 entry->atm_addr, ATM_ESA_LEN) == 0) { 1326 remove_vcc = 0; 1327 break; 1328 } 1329 } 1330 } 1331 if (remove_vcc) 1332 lec_arp_clear_vccs(to_remove); 1333 } 1334 skb_queue_purge(&to_remove->tx_wait); /* FIXME: good place for this? */ 1335 1336 pr_debug("Removed entry:%pM\n", to_remove->mac_addr); 1337 return 0; 1338 } 1339 1340 #if DEBUG_ARP_TABLE 1341 static const char *get_status_string(unsigned char st) 1342 { 1343 switch (st) { 1344 case ESI_UNKNOWN: 1345 return "ESI_UNKNOWN"; 1346 case ESI_ARP_PENDING: 1347 return "ESI_ARP_PENDING"; 1348 case ESI_VC_PENDING: 1349 return "ESI_VC_PENDING"; 1350 case ESI_FLUSH_PENDING: 1351 return "ESI_FLUSH_PENDING"; 1352 case ESI_FORWARD_DIRECT: 1353 return "ESI_FORWARD_DIRECT"; 1354 } 1355 return "<UNKNOWN>"; 1356 } 1357 1358 static void dump_arp_table(struct lec_priv *priv) 1359 { 1360 struct lec_arp_table *rulla; 1361 char buf[256]; 1362 int i, j, offset; 1363 1364 pr_info("Dump %p:\n", priv); 1365 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1366 hlist_for_each_entry(rulla, 1367 &priv->lec_arp_tables[i], next) { 1368 offset = 0; 1369 offset += sprintf(buf, "%d: %p\n", i, rulla); 1370 offset += sprintf(buf + offset, "Mac: %pM", 1371 rulla->mac_addr); 1372 offset += sprintf(buf + offset, " Atm:"); 1373 for (j = 0; j < ATM_ESA_LEN; j++) { 1374 offset += sprintf(buf + offset, 1375 "%2.2x ", 1376 rulla->atm_addr[j] & 0xff); 1377 } 1378 offset += sprintf(buf + offset, 1379 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1380 rulla->vcc ? rulla->vcc->vpi : 0, 1381 rulla->vcc ? rulla->vcc->vci : 0, 1382 rulla->recv_vcc ? rulla->recv_vcc-> 1383 vpi : 0, 1384 rulla->recv_vcc ? rulla->recv_vcc-> 1385 vci : 0, rulla->last_used, 1386 rulla->timestamp, rulla->no_tries); 1387 offset += 1388 sprintf(buf + offset, 1389 "Flags:%x, Packets_flooded:%x, Status: %s ", 1390 rulla->flags, rulla->packets_flooded, 1391 get_status_string(rulla->status)); 1392 pr_info("%s\n", buf); 1393 } 1394 } 1395 1396 if (!hlist_empty(&priv->lec_no_forward)) 1397 pr_info("No forward\n"); 1398 hlist_for_each_entry(rulla, &priv->lec_no_forward, next) { 1399 offset = 0; 1400 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1401 offset += sprintf(buf + offset, " Atm:"); 1402 for (j = 0; j < ATM_ESA_LEN; j++) { 1403 offset += sprintf(buf + offset, "%2.2x ", 1404 rulla->atm_addr[j] & 0xff); 1405 } 1406 offset += sprintf(buf + offset, 1407 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1408 rulla->vcc ? rulla->vcc->vpi : 0, 1409 rulla->vcc ? rulla->vcc->vci : 0, 1410 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1411 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1412 rulla->last_used, 1413 rulla->timestamp, rulla->no_tries); 1414 offset += sprintf(buf + offset, 1415 "Flags:%x, Packets_flooded:%x, Status: %s ", 1416 rulla->flags, rulla->packets_flooded, 1417 get_status_string(rulla->status)); 1418 pr_info("%s\n", buf); 1419 } 1420 1421 if (!hlist_empty(&priv->lec_arp_empty_ones)) 1422 pr_info("Empty ones\n"); 1423 hlist_for_each_entry(rulla, &priv->lec_arp_empty_ones, next) { 1424 offset = 0; 1425 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1426 offset += sprintf(buf + offset, " Atm:"); 1427 for (j = 0; j < ATM_ESA_LEN; j++) { 1428 offset += sprintf(buf + offset, "%2.2x ", 1429 rulla->atm_addr[j] & 0xff); 1430 } 1431 offset += sprintf(buf + offset, 1432 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1433 rulla->vcc ? rulla->vcc->vpi : 0, 1434 rulla->vcc ? rulla->vcc->vci : 0, 1435 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1436 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1437 rulla->last_used, 1438 rulla->timestamp, rulla->no_tries); 1439 offset += sprintf(buf + offset, 1440 "Flags:%x, Packets_flooded:%x, Status: %s ", 1441 rulla->flags, rulla->packets_flooded, 1442 get_status_string(rulla->status)); 1443 pr_info("%s", buf); 1444 } 1445 1446 if (!hlist_empty(&priv->mcast_fwds)) 1447 pr_info("Multicast Forward VCCs\n"); 1448 hlist_for_each_entry(rulla, &priv->mcast_fwds, next) { 1449 offset = 0; 1450 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1451 offset += sprintf(buf + offset, " Atm:"); 1452 for (j = 0; j < ATM_ESA_LEN; j++) { 1453 offset += sprintf(buf + offset, "%2.2x ", 1454 rulla->atm_addr[j] & 0xff); 1455 } 1456 offset += sprintf(buf + offset, 1457 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1458 rulla->vcc ? rulla->vcc->vpi : 0, 1459 rulla->vcc ? rulla->vcc->vci : 0, 1460 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1461 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1462 rulla->last_used, 1463 rulla->timestamp, rulla->no_tries); 1464 offset += sprintf(buf + offset, 1465 "Flags:%x, Packets_flooded:%x, Status: %s ", 1466 rulla->flags, rulla->packets_flooded, 1467 get_status_string(rulla->status)); 1468 pr_info("%s\n", buf); 1469 } 1470 1471 } 1472 #else 1473 #define dump_arp_table(priv) do { } while (0) 1474 #endif 1475 1476 /* 1477 * Destruction of arp-cache 1478 */ 1479 static void lec_arp_destroy(struct lec_priv *priv) 1480 { 1481 unsigned long flags; 1482 struct hlist_node *next; 1483 struct lec_arp_table *entry; 1484 int i; 1485 1486 cancel_delayed_work_sync(&priv->lec_arp_work); 1487 1488 /* 1489 * Remove all entries 1490 */ 1491 1492 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1493 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1494 hlist_for_each_entry_safe(entry, next, 1495 &priv->lec_arp_tables[i], next) { 1496 lec_arp_remove(priv, entry); 1497 lec_arp_put(entry); 1498 } 1499 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1500 } 1501 1502 hlist_for_each_entry_safe(entry, next, 1503 &priv->lec_arp_empty_ones, next) { 1504 del_timer_sync(&entry->timer); 1505 lec_arp_clear_vccs(entry); 1506 hlist_del(&entry->next); 1507 lec_arp_put(entry); 1508 } 1509 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1510 1511 hlist_for_each_entry_safe(entry, next, 1512 &priv->lec_no_forward, next) { 1513 del_timer_sync(&entry->timer); 1514 lec_arp_clear_vccs(entry); 1515 hlist_del(&entry->next); 1516 lec_arp_put(entry); 1517 } 1518 INIT_HLIST_HEAD(&priv->lec_no_forward); 1519 1520 hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) { 1521 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 1522 lec_arp_clear_vccs(entry); 1523 hlist_del(&entry->next); 1524 lec_arp_put(entry); 1525 } 1526 INIT_HLIST_HEAD(&priv->mcast_fwds); 1527 priv->mcast_vcc = NULL; 1528 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1529 } 1530 1531 /* 1532 * Find entry by mac_address 1533 */ 1534 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv, 1535 const unsigned char *mac_addr) 1536 { 1537 struct hlist_head *head; 1538 struct lec_arp_table *entry; 1539 1540 pr_debug("%pM\n", mac_addr); 1541 1542 head = &priv->lec_arp_tables[HASH(mac_addr[ETH_ALEN - 1])]; 1543 hlist_for_each_entry(entry, head, next) { 1544 if (ether_addr_equal(mac_addr, entry->mac_addr)) 1545 return entry; 1546 } 1547 return NULL; 1548 } 1549 1550 static struct lec_arp_table *make_entry(struct lec_priv *priv, 1551 const unsigned char *mac_addr) 1552 { 1553 struct lec_arp_table *to_return; 1554 1555 to_return = kzalloc(sizeof(struct lec_arp_table), GFP_ATOMIC); 1556 if (!to_return) { 1557 pr_info("LEC: Arp entry kmalloc failed\n"); 1558 return NULL; 1559 } 1560 ether_addr_copy(to_return->mac_addr, mac_addr); 1561 INIT_HLIST_NODE(&to_return->next); 1562 setup_timer(&to_return->timer, lec_arp_expire_arp, 1563 (unsigned long)to_return); 1564 to_return->last_used = jiffies; 1565 to_return->priv = priv; 1566 skb_queue_head_init(&to_return->tx_wait); 1567 refcount_set(&to_return->usage, 1); 1568 return to_return; 1569 } 1570 1571 /* Arp sent timer expired */ 1572 static void lec_arp_expire_arp(unsigned long data) 1573 { 1574 struct lec_arp_table *entry; 1575 1576 entry = (struct lec_arp_table *)data; 1577 1578 pr_debug("\n"); 1579 if (entry->status == ESI_ARP_PENDING) { 1580 if (entry->no_tries <= entry->priv->max_retry_count) { 1581 if (entry->is_rdesc) 1582 send_to_lecd(entry->priv, l_rdesc_arp_xmt, 1583 entry->mac_addr, NULL, NULL); 1584 else 1585 send_to_lecd(entry->priv, l_arp_xmt, 1586 entry->mac_addr, NULL, NULL); 1587 entry->no_tries++; 1588 } 1589 mod_timer(&entry->timer, jiffies + (1 * HZ)); 1590 } 1591 } 1592 1593 /* Unknown/unused vcc expire, remove associated entry */ 1594 static void lec_arp_expire_vcc(unsigned long data) 1595 { 1596 unsigned long flags; 1597 struct lec_arp_table *to_remove = (struct lec_arp_table *)data; 1598 struct lec_priv *priv = to_remove->priv; 1599 1600 del_timer(&to_remove->timer); 1601 1602 pr_debug("%p %p: vpi:%d vci:%d\n", 1603 to_remove, priv, 1604 to_remove->vcc ? to_remove->recv_vcc->vpi : 0, 1605 to_remove->vcc ? to_remove->recv_vcc->vci : 0); 1606 1607 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1608 hlist_del(&to_remove->next); 1609 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1610 1611 lec_arp_clear_vccs(to_remove); 1612 lec_arp_put(to_remove); 1613 } 1614 1615 static bool __lec_arp_check_expire(struct lec_arp_table *entry, 1616 unsigned long now, 1617 struct lec_priv *priv) 1618 { 1619 unsigned long time_to_check; 1620 1621 if ((entry->flags) & LEC_REMOTE_FLAG && priv->topology_change) 1622 time_to_check = priv->forward_delay_time; 1623 else 1624 time_to_check = priv->aging_time; 1625 1626 pr_debug("About to expire: %lx - %lx > %lx\n", 1627 now, entry->last_used, time_to_check); 1628 if (time_after(now, entry->last_used + time_to_check) && 1629 !(entry->flags & LEC_PERMANENT_FLAG) && 1630 !(entry->mac_addr[0] & 0x01)) { /* LANE2: 7.1.20 */ 1631 /* Remove entry */ 1632 pr_debug("Entry timed out\n"); 1633 lec_arp_remove(priv, entry); 1634 lec_arp_put(entry); 1635 } else { 1636 /* Something else */ 1637 if ((entry->status == ESI_VC_PENDING || 1638 entry->status == ESI_ARP_PENDING) && 1639 time_after_eq(now, entry->timestamp + 1640 priv->max_unknown_frame_time)) { 1641 entry->timestamp = jiffies; 1642 entry->packets_flooded = 0; 1643 if (entry->status == ESI_VC_PENDING) 1644 send_to_lecd(priv, l_svc_setup, 1645 entry->mac_addr, 1646 entry->atm_addr, 1647 NULL); 1648 } 1649 if (entry->status == ESI_FLUSH_PENDING && 1650 time_after_eq(now, entry->timestamp + 1651 priv->path_switching_delay)) { 1652 lec_arp_hold(entry); 1653 return true; 1654 } 1655 } 1656 1657 return false; 1658 } 1659 /* 1660 * Expire entries. 1661 * 1. Re-set timer 1662 * 2. For each entry, delete entries that have aged past the age limit. 1663 * 3. For each entry, depending on the status of the entry, perform 1664 * the following maintenance. 1665 * a. If status is ESI_VC_PENDING or ESI_ARP_PENDING then if the 1666 * tick_count is above the max_unknown_frame_time, clear 1667 * the tick_count to zero and clear the packets_flooded counter 1668 * to zero. This supports the packet rate limit per address 1669 * while flooding unknowns. 1670 * b. If the status is ESI_FLUSH_PENDING and the tick_count is greater 1671 * than or equal to the path_switching_delay, change the status 1672 * to ESI_FORWARD_DIRECT. This causes the flush period to end 1673 * regardless of the progress of the flush protocol. 1674 */ 1675 static void lec_arp_check_expire(struct work_struct *work) 1676 { 1677 unsigned long flags; 1678 struct lec_priv *priv = 1679 container_of(work, struct lec_priv, lec_arp_work.work); 1680 struct hlist_node *next; 1681 struct lec_arp_table *entry; 1682 unsigned long now; 1683 int i; 1684 1685 pr_debug("%p\n", priv); 1686 now = jiffies; 1687 restart: 1688 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1689 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1690 hlist_for_each_entry_safe(entry, next, 1691 &priv->lec_arp_tables[i], next) { 1692 if (__lec_arp_check_expire(entry, now, priv)) { 1693 struct sk_buff *skb; 1694 struct atm_vcc *vcc = entry->vcc; 1695 1696 spin_unlock_irqrestore(&priv->lec_arp_lock, 1697 flags); 1698 while ((skb = skb_dequeue(&entry->tx_wait))) 1699 lec_send(vcc, skb); 1700 entry->last_used = jiffies; 1701 entry->status = ESI_FORWARD_DIRECT; 1702 lec_arp_put(entry); 1703 1704 goto restart; 1705 } 1706 } 1707 } 1708 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1709 1710 schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL); 1711 } 1712 1713 /* 1714 * Try to find vcc where mac_address is attached. 1715 * 1716 */ 1717 static struct atm_vcc *lec_arp_resolve(struct lec_priv *priv, 1718 const unsigned char *mac_to_find, 1719 int is_rdesc, 1720 struct lec_arp_table **ret_entry) 1721 { 1722 unsigned long flags; 1723 struct lec_arp_table *entry; 1724 struct atm_vcc *found; 1725 1726 if (mac_to_find[0] & 0x01) { 1727 switch (priv->lane_version) { 1728 case 1: 1729 return priv->mcast_vcc; 1730 case 2: /* LANE2 wants arp for multicast addresses */ 1731 if (ether_addr_equal(mac_to_find, bus_mac)) 1732 return priv->mcast_vcc; 1733 break; 1734 default: 1735 break; 1736 } 1737 } 1738 1739 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1740 entry = lec_arp_find(priv, mac_to_find); 1741 1742 if (entry) { 1743 if (entry->status == ESI_FORWARD_DIRECT) { 1744 /* Connection Ok */ 1745 entry->last_used = jiffies; 1746 lec_arp_hold(entry); 1747 *ret_entry = entry; 1748 found = entry->vcc; 1749 goto out; 1750 } 1751 /* 1752 * If the LE_ARP cache entry is still pending, reset count to 0 1753 * so another LE_ARP request can be made for this frame. 1754 */ 1755 if (entry->status == ESI_ARP_PENDING) 1756 entry->no_tries = 0; 1757 /* 1758 * Data direct VC not yet set up, check to see if the unknown 1759 * frame count is greater than the limit. If the limit has 1760 * not been reached, allow the caller to send packet to 1761 * BUS. 1762 */ 1763 if (entry->status != ESI_FLUSH_PENDING && 1764 entry->packets_flooded < 1765 priv->maximum_unknown_frame_count) { 1766 entry->packets_flooded++; 1767 pr_debug("Flooding..\n"); 1768 found = priv->mcast_vcc; 1769 goto out; 1770 } 1771 /* 1772 * We got here because entry->status == ESI_FLUSH_PENDING 1773 * or BUS flood limit was reached for an entry which is 1774 * in ESI_ARP_PENDING or ESI_VC_PENDING state. 1775 */ 1776 lec_arp_hold(entry); 1777 *ret_entry = entry; 1778 pr_debug("entry->status %d entry->vcc %p\n", entry->status, 1779 entry->vcc); 1780 found = NULL; 1781 } else { 1782 /* No matching entry was found */ 1783 entry = make_entry(priv, mac_to_find); 1784 pr_debug("Making entry\n"); 1785 if (!entry) { 1786 found = priv->mcast_vcc; 1787 goto out; 1788 } 1789 lec_arp_add(priv, entry); 1790 /* We want arp-request(s) to be sent */ 1791 entry->packets_flooded = 1; 1792 entry->status = ESI_ARP_PENDING; 1793 entry->no_tries = 1; 1794 entry->last_used = entry->timestamp = jiffies; 1795 entry->is_rdesc = is_rdesc; 1796 if (entry->is_rdesc) 1797 send_to_lecd(priv, l_rdesc_arp_xmt, mac_to_find, NULL, 1798 NULL); 1799 else 1800 send_to_lecd(priv, l_arp_xmt, mac_to_find, NULL, NULL); 1801 entry->timer.expires = jiffies + (1 * HZ); 1802 entry->timer.function = lec_arp_expire_arp; 1803 add_timer(&entry->timer); 1804 found = priv->mcast_vcc; 1805 } 1806 1807 out: 1808 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1809 return found; 1810 } 1811 1812 static int 1813 lec_addr_delete(struct lec_priv *priv, const unsigned char *atm_addr, 1814 unsigned long permanent) 1815 { 1816 unsigned long flags; 1817 struct hlist_node *next; 1818 struct lec_arp_table *entry; 1819 int i; 1820 1821 pr_debug("\n"); 1822 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1823 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1824 hlist_for_each_entry_safe(entry, next, 1825 &priv->lec_arp_tables[i], next) { 1826 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN) && 1827 (permanent || 1828 !(entry->flags & LEC_PERMANENT_FLAG))) { 1829 lec_arp_remove(priv, entry); 1830 lec_arp_put(entry); 1831 } 1832 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1833 return 0; 1834 } 1835 } 1836 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1837 return -1; 1838 } 1839 1840 /* 1841 * Notifies: Response to arp_request (atm_addr != NULL) 1842 */ 1843 static void 1844 lec_arp_update(struct lec_priv *priv, const unsigned char *mac_addr, 1845 const unsigned char *atm_addr, unsigned long remoteflag, 1846 unsigned int targetless_le_arp) 1847 { 1848 unsigned long flags; 1849 struct hlist_node *next; 1850 struct lec_arp_table *entry, *tmp; 1851 int i; 1852 1853 pr_debug("%smac:%pM\n", 1854 (targetless_le_arp) ? "targetless " : "", mac_addr); 1855 1856 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1857 entry = lec_arp_find(priv, mac_addr); 1858 if (entry == NULL && targetless_le_arp) 1859 goto out; /* 1860 * LANE2: ignore targetless LE_ARPs for which 1861 * we have no entry in the cache. 7.1.30 1862 */ 1863 if (!hlist_empty(&priv->lec_arp_empty_ones)) { 1864 hlist_for_each_entry_safe(entry, next, 1865 &priv->lec_arp_empty_ones, next) { 1866 if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) { 1867 hlist_del(&entry->next); 1868 del_timer(&entry->timer); 1869 tmp = lec_arp_find(priv, mac_addr); 1870 if (tmp) { 1871 del_timer(&tmp->timer); 1872 tmp->status = ESI_FORWARD_DIRECT; 1873 memcpy(tmp->atm_addr, atm_addr, ATM_ESA_LEN); 1874 tmp->vcc = entry->vcc; 1875 tmp->old_push = entry->old_push; 1876 tmp->last_used = jiffies; 1877 del_timer(&entry->timer); 1878 lec_arp_put(entry); 1879 entry = tmp; 1880 } else { 1881 entry->status = ESI_FORWARD_DIRECT; 1882 ether_addr_copy(entry->mac_addr, 1883 mac_addr); 1884 entry->last_used = jiffies; 1885 lec_arp_add(priv, entry); 1886 } 1887 if (remoteflag) 1888 entry->flags |= LEC_REMOTE_FLAG; 1889 else 1890 entry->flags &= ~LEC_REMOTE_FLAG; 1891 pr_debug("After update\n"); 1892 dump_arp_table(priv); 1893 goto out; 1894 } 1895 } 1896 } 1897 1898 entry = lec_arp_find(priv, mac_addr); 1899 if (!entry) { 1900 entry = make_entry(priv, mac_addr); 1901 if (!entry) 1902 goto out; 1903 entry->status = ESI_UNKNOWN; 1904 lec_arp_add(priv, entry); 1905 /* Temporary, changes before end of function */ 1906 } 1907 memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN); 1908 del_timer(&entry->timer); 1909 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1910 hlist_for_each_entry(tmp, 1911 &priv->lec_arp_tables[i], next) { 1912 if (entry != tmp && 1913 !memcmp(tmp->atm_addr, atm_addr, ATM_ESA_LEN)) { 1914 /* Vcc to this host exists */ 1915 if (tmp->status > ESI_VC_PENDING) { 1916 /* 1917 * ESI_FLUSH_PENDING, 1918 * ESI_FORWARD_DIRECT 1919 */ 1920 entry->vcc = tmp->vcc; 1921 entry->old_push = tmp->old_push; 1922 } 1923 entry->status = tmp->status; 1924 break; 1925 } 1926 } 1927 } 1928 if (remoteflag) 1929 entry->flags |= LEC_REMOTE_FLAG; 1930 else 1931 entry->flags &= ~LEC_REMOTE_FLAG; 1932 if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) { 1933 entry->status = ESI_VC_PENDING; 1934 send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL); 1935 } 1936 pr_debug("After update2\n"); 1937 dump_arp_table(priv); 1938 out: 1939 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1940 } 1941 1942 /* 1943 * Notifies: Vcc setup ready 1944 */ 1945 static void 1946 lec_vcc_added(struct lec_priv *priv, const struct atmlec_ioc *ioc_data, 1947 struct atm_vcc *vcc, 1948 void (*old_push) (struct atm_vcc *vcc, struct sk_buff *skb)) 1949 { 1950 unsigned long flags; 1951 struct lec_arp_table *entry; 1952 int i, found_entry = 0; 1953 1954 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1955 /* Vcc for Multicast Forward. No timer, LANEv2 7.1.20 and 2.3.5.3 */ 1956 if (ioc_data->receive == 2) { 1957 pr_debug("LEC_ARP: Attaching mcast forward\n"); 1958 #if 0 1959 entry = lec_arp_find(priv, bus_mac); 1960 if (!entry) { 1961 pr_info("LEC_ARP: Multicast entry not found!\n"); 1962 goto out; 1963 } 1964 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1965 entry->recv_vcc = vcc; 1966 entry->old_recv_push = old_push; 1967 #endif 1968 entry = make_entry(priv, bus_mac); 1969 if (entry == NULL) 1970 goto out; 1971 del_timer(&entry->timer); 1972 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1973 entry->recv_vcc = vcc; 1974 entry->old_recv_push = old_push; 1975 hlist_add_head(&entry->next, &priv->mcast_fwds); 1976 goto out; 1977 } else if (ioc_data->receive == 1) { 1978 /* 1979 * Vcc which we don't want to make default vcc, 1980 * attach it anyway. 1981 */ 1982 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", 1983 ioc_data->atm_addr[0], ioc_data->atm_addr[1], 1984 ioc_data->atm_addr[2], ioc_data->atm_addr[3], 1985 ioc_data->atm_addr[4], ioc_data->atm_addr[5], 1986 ioc_data->atm_addr[6], ioc_data->atm_addr[7], 1987 ioc_data->atm_addr[8], ioc_data->atm_addr[9], 1988 ioc_data->atm_addr[10], ioc_data->atm_addr[11], 1989 ioc_data->atm_addr[12], ioc_data->atm_addr[13], 1990 ioc_data->atm_addr[14], ioc_data->atm_addr[15], 1991 ioc_data->atm_addr[16], ioc_data->atm_addr[17], 1992 ioc_data->atm_addr[18], ioc_data->atm_addr[19]); 1993 entry = make_entry(priv, bus_mac); 1994 if (entry == NULL) 1995 goto out; 1996 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 1997 eth_zero_addr(entry->mac_addr); 1998 entry->recv_vcc = vcc; 1999 entry->old_recv_push = old_push; 2000 entry->status = ESI_UNKNOWN; 2001 entry->timer.expires = jiffies + priv->vcc_timeout_period; 2002 entry->timer.function = lec_arp_expire_vcc; 2003 hlist_add_head(&entry->next, &priv->lec_no_forward); 2004 add_timer(&entry->timer); 2005 dump_arp_table(priv); 2006 goto out; 2007 } 2008 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", 2009 ioc_data->atm_addr[0], ioc_data->atm_addr[1], 2010 ioc_data->atm_addr[2], ioc_data->atm_addr[3], 2011 ioc_data->atm_addr[4], ioc_data->atm_addr[5], 2012 ioc_data->atm_addr[6], ioc_data->atm_addr[7], 2013 ioc_data->atm_addr[8], ioc_data->atm_addr[9], 2014 ioc_data->atm_addr[10], ioc_data->atm_addr[11], 2015 ioc_data->atm_addr[12], ioc_data->atm_addr[13], 2016 ioc_data->atm_addr[14], ioc_data->atm_addr[15], 2017 ioc_data->atm_addr[16], ioc_data->atm_addr[17], 2018 ioc_data->atm_addr[18], ioc_data->atm_addr[19]); 2019 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2020 hlist_for_each_entry(entry, 2021 &priv->lec_arp_tables[i], next) { 2022 if (memcmp 2023 (ioc_data->atm_addr, entry->atm_addr, 2024 ATM_ESA_LEN) == 0) { 2025 pr_debug("LEC_ARP: Attaching data direct\n"); 2026 pr_debug("Currently -> Vcc: %d, Rvcc:%d\n", 2027 entry->vcc ? entry->vcc->vci : 0, 2028 entry->recv_vcc ? entry->recv_vcc-> 2029 vci : 0); 2030 found_entry = 1; 2031 del_timer(&entry->timer); 2032 entry->vcc = vcc; 2033 entry->old_push = old_push; 2034 if (entry->status == ESI_VC_PENDING) { 2035 if (priv->maximum_unknown_frame_count 2036 == 0) 2037 entry->status = 2038 ESI_FORWARD_DIRECT; 2039 else { 2040 entry->timestamp = jiffies; 2041 entry->status = 2042 ESI_FLUSH_PENDING; 2043 #if 0 2044 send_to_lecd(priv, l_flush_xmt, 2045 NULL, 2046 entry->atm_addr, 2047 NULL); 2048 #endif 2049 } 2050 } else { 2051 /* 2052 * They were forming a connection 2053 * to us, and we to them. Our 2054 * ATM address is numerically lower 2055 * than theirs, so we make connection 2056 * we formed into default VCC (8.1.11). 2057 * Connection they made gets torn 2058 * down. This might confuse some 2059 * clients. Can be changed if 2060 * someone reports trouble... 2061 */ 2062 ; 2063 } 2064 } 2065 } 2066 } 2067 if (found_entry) { 2068 pr_debug("After vcc was added\n"); 2069 dump_arp_table(priv); 2070 goto out; 2071 } 2072 /* 2073 * Not found, snatch address from first data packet that arrives 2074 * from this vcc 2075 */ 2076 entry = make_entry(priv, bus_mac); 2077 if (!entry) 2078 goto out; 2079 entry->vcc = vcc; 2080 entry->old_push = old_push; 2081 memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN); 2082 eth_zero_addr(entry->mac_addr); 2083 entry->status = ESI_UNKNOWN; 2084 hlist_add_head(&entry->next, &priv->lec_arp_empty_ones); 2085 entry->timer.expires = jiffies + priv->vcc_timeout_period; 2086 entry->timer.function = lec_arp_expire_vcc; 2087 add_timer(&entry->timer); 2088 pr_debug("After vcc was added\n"); 2089 dump_arp_table(priv); 2090 out: 2091 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2092 } 2093 2094 static void lec_flush_complete(struct lec_priv *priv, unsigned long tran_id) 2095 { 2096 unsigned long flags; 2097 struct lec_arp_table *entry; 2098 int i; 2099 2100 pr_debug("%lx\n", tran_id); 2101 restart: 2102 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2103 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2104 hlist_for_each_entry(entry, 2105 &priv->lec_arp_tables[i], next) { 2106 if (entry->flush_tran_id == tran_id && 2107 entry->status == ESI_FLUSH_PENDING) { 2108 struct sk_buff *skb; 2109 struct atm_vcc *vcc = entry->vcc; 2110 2111 lec_arp_hold(entry); 2112 spin_unlock_irqrestore(&priv->lec_arp_lock, 2113 flags); 2114 while ((skb = skb_dequeue(&entry->tx_wait))) 2115 lec_send(vcc, skb); 2116 entry->last_used = jiffies; 2117 entry->status = ESI_FORWARD_DIRECT; 2118 lec_arp_put(entry); 2119 pr_debug("LEC_ARP: Flushed\n"); 2120 goto restart; 2121 } 2122 } 2123 } 2124 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2125 dump_arp_table(priv); 2126 } 2127 2128 static void 2129 lec_set_flush_tran_id(struct lec_priv *priv, 2130 const unsigned char *atm_addr, unsigned long tran_id) 2131 { 2132 unsigned long flags; 2133 struct lec_arp_table *entry; 2134 int i; 2135 2136 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2137 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 2138 hlist_for_each_entry(entry, 2139 &priv->lec_arp_tables[i], next) { 2140 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) { 2141 entry->flush_tran_id = tran_id; 2142 pr_debug("Set flush transaction id to %lx for %p\n", 2143 tran_id, entry); 2144 } 2145 } 2146 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2147 } 2148 2149 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc) 2150 { 2151 unsigned long flags; 2152 unsigned char mac_addr[] = { 2153 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2154 }; 2155 struct lec_arp_table *to_add; 2156 struct lec_vcc_priv *vpriv; 2157 int err = 0; 2158 2159 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 2160 if (!vpriv) 2161 return -ENOMEM; 2162 vpriv->xoff = 0; 2163 vpriv->old_pop = vcc->pop; 2164 vcc->user_back = vpriv; 2165 vcc->pop = lec_pop; 2166 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2167 to_add = make_entry(priv, mac_addr); 2168 if (!to_add) { 2169 vcc->pop = vpriv->old_pop; 2170 kfree(vpriv); 2171 err = -ENOMEM; 2172 goto out; 2173 } 2174 memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN); 2175 to_add->status = ESI_FORWARD_DIRECT; 2176 to_add->flags |= LEC_PERMANENT_FLAG; 2177 to_add->vcc = vcc; 2178 to_add->old_push = vcc->push; 2179 vcc->push = lec_push; 2180 priv->mcast_vcc = vcc; 2181 lec_arp_add(priv, to_add); 2182 out: 2183 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2184 return err; 2185 } 2186 2187 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc) 2188 { 2189 unsigned long flags; 2190 struct hlist_node *next; 2191 struct lec_arp_table *entry; 2192 int i; 2193 2194 pr_debug("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc->vpi, vcc->vci); 2195 dump_arp_table(priv); 2196 2197 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2198 2199 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2200 hlist_for_each_entry_safe(entry, next, 2201 &priv->lec_arp_tables[i], next) { 2202 if (vcc == entry->vcc) { 2203 lec_arp_remove(priv, entry); 2204 lec_arp_put(entry); 2205 if (priv->mcast_vcc == vcc) 2206 priv->mcast_vcc = NULL; 2207 } 2208 } 2209 } 2210 2211 hlist_for_each_entry_safe(entry, next, 2212 &priv->lec_arp_empty_ones, next) { 2213 if (entry->vcc == vcc) { 2214 lec_arp_clear_vccs(entry); 2215 del_timer(&entry->timer); 2216 hlist_del(&entry->next); 2217 lec_arp_put(entry); 2218 } 2219 } 2220 2221 hlist_for_each_entry_safe(entry, next, 2222 &priv->lec_no_forward, next) { 2223 if (entry->recv_vcc == vcc) { 2224 lec_arp_clear_vccs(entry); 2225 del_timer(&entry->timer); 2226 hlist_del(&entry->next); 2227 lec_arp_put(entry); 2228 } 2229 } 2230 2231 hlist_for_each_entry_safe(entry, next, &priv->mcast_fwds, next) { 2232 if (entry->recv_vcc == vcc) { 2233 lec_arp_clear_vccs(entry); 2234 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 2235 hlist_del(&entry->next); 2236 lec_arp_put(entry); 2237 } 2238 } 2239 2240 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2241 dump_arp_table(priv); 2242 } 2243 2244 static void 2245 lec_arp_check_empties(struct lec_priv *priv, 2246 struct atm_vcc *vcc, struct sk_buff *skb) 2247 { 2248 unsigned long flags; 2249 struct hlist_node *next; 2250 struct lec_arp_table *entry, *tmp; 2251 struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data; 2252 unsigned char *src = hdr->h_source; 2253 2254 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2255 hlist_for_each_entry_safe(entry, next, 2256 &priv->lec_arp_empty_ones, next) { 2257 if (vcc == entry->vcc) { 2258 del_timer(&entry->timer); 2259 ether_addr_copy(entry->mac_addr, src); 2260 entry->status = ESI_FORWARD_DIRECT; 2261 entry->last_used = jiffies; 2262 /* We might have got an entry */ 2263 tmp = lec_arp_find(priv, src); 2264 if (tmp) { 2265 lec_arp_remove(priv, tmp); 2266 lec_arp_put(tmp); 2267 } 2268 hlist_del(&entry->next); 2269 lec_arp_add(priv, entry); 2270 goto out; 2271 } 2272 } 2273 pr_debug("LEC_ARP: Arp_check_empties: entry not found!\n"); 2274 out: 2275 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2276 } 2277 2278 MODULE_LICENSE("GPL"); 2279