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, skb2->len); 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 kfree_skb(skb); 235 if (skb2 == NULL) 236 return NETDEV_TX_OK; 237 skb = skb2; 238 } 239 skb_push(skb, 2); 240 241 /* Put le header to place */ 242 lec_h = (struct lecdatahdr_8023 *)skb->data; 243 lec_h->le_header = htons(priv->lecid); 244 245 #if DUMP_PACKETS >= 2 246 #define MAX_DUMP_SKB 99 247 #elif DUMP_PACKETS >= 1 248 #define MAX_DUMP_SKB 30 249 #endif 250 #if DUMP_PACKETS >= 1 251 printk(KERN_DEBUG "%s: send datalen:%ld lecid:%4.4x\n", 252 dev->name, skb->len, priv->lecid); 253 print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1, 254 skb->data, min(skb->len, MAX_DUMP_SKB), true); 255 #endif /* DUMP_PACKETS >= 1 */ 256 257 /* Minimum ethernet-frame size */ 258 min_frame_size = LEC_MINIMUM_8023_SIZE; 259 if (skb->len < min_frame_size) { 260 if ((skb->len + skb_tailroom(skb)) < min_frame_size) { 261 skb2 = skb_copy_expand(skb, 0, 262 min_frame_size - skb->truesize, 263 GFP_ATOMIC); 264 dev_kfree_skb(skb); 265 if (skb2 == NULL) { 266 dev->stats.tx_dropped++; 267 return NETDEV_TX_OK; 268 } 269 skb = skb2; 270 } 271 skb_put(skb, min_frame_size - skb->len); 272 } 273 274 /* Send to right vcc */ 275 is_rdesc = 0; 276 dst = lec_h->h_dest; 277 entry = NULL; 278 vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry); 279 pr_debug("%s:vcc:%p vcc_flags:%lx, entry:%p\n", 280 dev->name, vcc, vcc ? vcc->flags : 0, entry); 281 if (!vcc || !test_bit(ATM_VF_READY, &vcc->flags)) { 282 if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) { 283 pr_debug("%s:queuing packet, MAC address %pM\n", 284 dev->name, lec_h->h_dest); 285 skb_queue_tail(&entry->tx_wait, skb); 286 } else { 287 pr_debug("%s:tx queue full or no arp entry, dropping, MAC address: %pM\n", 288 dev->name, lec_h->h_dest); 289 dev->stats.tx_dropped++; 290 dev_kfree_skb(skb); 291 } 292 goto out; 293 } 294 #if DUMP_PACKETS > 0 295 printk(KERN_DEBUG "%s:sending to vpi:%d vci:%d\n", 296 dev->name, vcc->vpi, vcc->vci); 297 #endif /* DUMP_PACKETS > 0 */ 298 299 while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) { 300 pr_debug("emptying tx queue, MAC address %pM\n", lec_h->h_dest); 301 lec_send(vcc, skb2); 302 } 303 304 lec_send(vcc, skb); 305 306 if (!atm_may_send(vcc, 0)) { 307 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 308 309 vpriv->xoff = 1; 310 netif_stop_queue(dev); 311 312 /* 313 * vcc->pop() might have occurred in between, making 314 * the vcc usuable again. Since xmit is serialized, 315 * this is the only situation we have to re-test. 316 */ 317 318 if (atm_may_send(vcc, 0)) 319 netif_wake_queue(dev); 320 } 321 322 out: 323 if (entry) 324 lec_arp_put(entry); 325 dev->trans_start = jiffies; 326 return NETDEV_TX_OK; 327 } 328 329 /* The inverse routine to net_open(). */ 330 static int lec_close(struct net_device *dev) 331 { 332 netif_stop_queue(dev); 333 return 0; 334 } 335 336 static int lec_atm_send(struct atm_vcc *vcc, struct sk_buff *skb) 337 { 338 unsigned long flags; 339 struct net_device *dev = (struct net_device *)vcc->proto_data; 340 struct lec_priv *priv = netdev_priv(dev); 341 struct atmlec_msg *mesg; 342 struct lec_arp_table *entry; 343 int i; 344 char *tmp; /* FIXME */ 345 346 atomic_sub(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc); 347 mesg = (struct atmlec_msg *)skb->data; 348 tmp = skb->data; 349 tmp += sizeof(struct atmlec_msg); 350 pr_debug("%s: msg from zeppelin:%d\n", dev->name, mesg->type); 351 switch (mesg->type) { 352 case l_set_mac_addr: 353 for (i = 0; i < 6; i++) 354 dev->dev_addr[i] = mesg->content.normal.mac_addr[i]; 355 break; 356 case l_del_mac_addr: 357 for (i = 0; i < 6; i++) 358 dev->dev_addr[i] = 0; 359 break; 360 case l_addr_delete: 361 lec_addr_delete(priv, mesg->content.normal.atm_addr, 362 mesg->content.normal.flag); 363 break; 364 case l_topology_change: 365 priv->topology_change = mesg->content.normal.flag; 366 break; 367 case l_flush_complete: 368 lec_flush_complete(priv, mesg->content.normal.flag); 369 break; 370 case l_narp_req: /* LANE2: see 7.1.35 in the lane2 spec */ 371 spin_lock_irqsave(&priv->lec_arp_lock, flags); 372 entry = lec_arp_find(priv, mesg->content.normal.mac_addr); 373 lec_arp_remove(priv, entry); 374 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 375 376 if (mesg->content.normal.no_source_le_narp) 377 break; 378 /* FALL THROUGH */ 379 case l_arp_update: 380 lec_arp_update(priv, mesg->content.normal.mac_addr, 381 mesg->content.normal.atm_addr, 382 mesg->content.normal.flag, 383 mesg->content.normal.targetless_le_arp); 384 pr_debug("in l_arp_update\n"); 385 if (mesg->sizeoftlvs != 0) { /* LANE2 3.1.5 */ 386 pr_debug("LANE2 3.1.5, got tlvs, size %d\n", 387 mesg->sizeoftlvs); 388 lane2_associate_ind(dev, mesg->content.normal.mac_addr, 389 tmp, mesg->sizeoftlvs); 390 } 391 break; 392 case l_config: 393 priv->maximum_unknown_frame_count = 394 mesg->content.config.maximum_unknown_frame_count; 395 priv->max_unknown_frame_time = 396 (mesg->content.config.max_unknown_frame_time * HZ); 397 priv->max_retry_count = mesg->content.config.max_retry_count; 398 priv->aging_time = (mesg->content.config.aging_time * HZ); 399 priv->forward_delay_time = 400 (mesg->content.config.forward_delay_time * HZ); 401 priv->arp_response_time = 402 (mesg->content.config.arp_response_time * HZ); 403 priv->flush_timeout = (mesg->content.config.flush_timeout * HZ); 404 priv->path_switching_delay = 405 (mesg->content.config.path_switching_delay * HZ); 406 priv->lane_version = mesg->content.config.lane_version; 407 /* LANE2 */ 408 priv->lane2_ops = NULL; 409 if (priv->lane_version > 1) 410 priv->lane2_ops = &lane2_ops; 411 if (dev_set_mtu(dev, mesg->content.config.mtu)) 412 pr_info("%s: change_mtu to %d failed\n", 413 dev->name, mesg->content.config.mtu); 414 priv->is_proxy = mesg->content.config.is_proxy; 415 break; 416 case l_flush_tran_id: 417 lec_set_flush_tran_id(priv, mesg->content.normal.atm_addr, 418 mesg->content.normal.flag); 419 break; 420 case l_set_lecid: 421 priv->lecid = 422 (unsigned short)(0xffff & mesg->content.normal.flag); 423 break; 424 case l_should_bridge: 425 #if defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) 426 { 427 pr_debug("%s: bridge zeppelin asks about %pM\n", 428 dev->name, mesg->content.proxy.mac_addr); 429 430 if (br_fdb_test_addr_hook == NULL) 431 break; 432 433 if (br_fdb_test_addr_hook(dev, mesg->content.proxy.mac_addr)) { 434 /* hit from bridge table, send LE_ARP_RESPONSE */ 435 struct sk_buff *skb2; 436 struct sock *sk; 437 438 pr_debug("%s: entry found, responding to zeppelin\n", 439 dev->name); 440 skb2 = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC); 441 if (skb2 == NULL) 442 break; 443 skb2->len = sizeof(struct atmlec_msg); 444 skb_copy_to_linear_data(skb2, mesg, sizeof(*mesg)); 445 atm_force_charge(priv->lecd, skb2->truesize); 446 sk = sk_atm(priv->lecd); 447 skb_queue_tail(&sk->sk_receive_queue, skb2); 448 sk->sk_data_ready(sk, skb2->len); 449 } 450 } 451 #endif /* defined(CONFIG_BRIDGE) || defined(CONFIG_BRIDGE_MODULE) */ 452 break; 453 default: 454 pr_info("%s: Unknown message type %d\n", dev->name, mesg->type); 455 dev_kfree_skb(skb); 456 return -EINVAL; 457 } 458 dev_kfree_skb(skb); 459 return 0; 460 } 461 462 static void lec_atm_close(struct atm_vcc *vcc) 463 { 464 struct sk_buff *skb; 465 struct net_device *dev = (struct net_device *)vcc->proto_data; 466 struct lec_priv *priv = netdev_priv(dev); 467 468 priv->lecd = NULL; 469 /* Do something needful? */ 470 471 netif_stop_queue(dev); 472 lec_arp_destroy(priv); 473 474 if (skb_peek(&sk_atm(vcc)->sk_receive_queue)) 475 pr_info("%s closing with messages pending\n", dev->name); 476 while ((skb = skb_dequeue(&sk_atm(vcc)->sk_receive_queue))) { 477 atm_return(vcc, skb->truesize); 478 dev_kfree_skb(skb); 479 } 480 481 pr_info("%s: Shut down!\n", dev->name); 482 module_put(THIS_MODULE); 483 } 484 485 static struct atmdev_ops lecdev_ops = { 486 .close = lec_atm_close, 487 .send = lec_atm_send 488 }; 489 490 static struct atm_dev lecatm_dev = { 491 .ops = &lecdev_ops, 492 .type = "lec", 493 .number = 999, /* dummy device number */ 494 .lock = __SPIN_LOCK_UNLOCKED(lecatm_dev.lock) 495 }; 496 497 /* 498 * LANE2: new argument struct sk_buff *data contains 499 * the LE_ARP based TLVs introduced in the LANE2 spec 500 */ 501 static int 502 send_to_lecd(struct lec_priv *priv, atmlec_msg_type type, 503 const unsigned char *mac_addr, const unsigned char *atm_addr, 504 struct sk_buff *data) 505 { 506 struct sock *sk; 507 struct sk_buff *skb; 508 struct atmlec_msg *mesg; 509 510 if (!priv || !priv->lecd) 511 return -1; 512 skb = alloc_skb(sizeof(struct atmlec_msg), GFP_ATOMIC); 513 if (!skb) 514 return -1; 515 skb->len = sizeof(struct atmlec_msg); 516 mesg = (struct atmlec_msg *)skb->data; 517 memset(mesg, 0, sizeof(struct atmlec_msg)); 518 mesg->type = type; 519 if (data != NULL) 520 mesg->sizeoftlvs = data->len; 521 if (mac_addr) 522 memcpy(&mesg->content.normal.mac_addr, mac_addr, ETH_ALEN); 523 else 524 mesg->content.normal.targetless_le_arp = 1; 525 if (atm_addr) 526 memcpy(&mesg->content.normal.atm_addr, atm_addr, ATM_ESA_LEN); 527 528 atm_force_charge(priv->lecd, skb->truesize); 529 sk = sk_atm(priv->lecd); 530 skb_queue_tail(&sk->sk_receive_queue, skb); 531 sk->sk_data_ready(sk, skb->len); 532 533 if (data != NULL) { 534 pr_debug("about to send %d bytes of data\n", data->len); 535 atm_force_charge(priv->lecd, data->truesize); 536 skb_queue_tail(&sk->sk_receive_queue, data); 537 sk->sk_data_ready(sk, skb->len); 538 } 539 540 return 0; 541 } 542 543 /* shamelessly stolen from drivers/net/net_init.c */ 544 static int lec_change_mtu(struct net_device *dev, int new_mtu) 545 { 546 if ((new_mtu < 68) || (new_mtu > 18190)) 547 return -EINVAL; 548 dev->mtu = new_mtu; 549 return 0; 550 } 551 552 static void lec_set_multicast_list(struct net_device *dev) 553 { 554 /* 555 * by default, all multicast frames arrive over the bus. 556 * eventually support selective multicast service 557 */ 558 } 559 560 static const struct net_device_ops lec_netdev_ops = { 561 .ndo_open = lec_open, 562 .ndo_stop = lec_close, 563 .ndo_start_xmit = lec_start_xmit, 564 .ndo_change_mtu = lec_change_mtu, 565 .ndo_tx_timeout = lec_tx_timeout, 566 .ndo_set_rx_mode = lec_set_multicast_list, 567 }; 568 569 static const unsigned char lec_ctrl_magic[] = { 570 0xff, 571 0x00, 572 0x01, 573 0x01 574 }; 575 576 #define LEC_DATA_DIRECT_8023 2 577 #define LEC_DATA_DIRECT_8025 3 578 579 static int lec_is_data_direct(struct atm_vcc *vcc) 580 { 581 return ((vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8023) || 582 (vcc->sap.blli[0].l3.tr9577.snap[4] == LEC_DATA_DIRECT_8025)); 583 } 584 585 static void lec_push(struct atm_vcc *vcc, struct sk_buff *skb) 586 { 587 unsigned long flags; 588 struct net_device *dev = (struct net_device *)vcc->proto_data; 589 struct lec_priv *priv = netdev_priv(dev); 590 591 #if DUMP_PACKETS > 0 592 printk(KERN_DEBUG "%s: vcc vpi:%d vci:%d\n", 593 dev->name, vcc->vpi, vcc->vci); 594 #endif 595 if (!skb) { 596 pr_debug("%s: null skb\n", dev->name); 597 lec_vcc_close(priv, vcc); 598 return; 599 } 600 #if DUMP_PACKETS >= 2 601 #define MAX_SKB_DUMP 99 602 #elif DUMP_PACKETS >= 1 603 #define MAX_SKB_DUMP 30 604 #endif 605 #if DUMP_PACKETS > 0 606 printk(KERN_DEBUG "%s: rcv datalen:%ld lecid:%4.4x\n", 607 dev->name, skb->len, priv->lecid); 608 print_hex_dump(KERN_DEBUG, "", DUMP_OFFSET, 16, 1, 609 skb->data, min(MAX_SKB_DUMP, skb->len), true); 610 #endif /* DUMP_PACKETS > 0 */ 611 if (memcmp(skb->data, lec_ctrl_magic, 4) == 0) { 612 /* Control frame, to daemon */ 613 struct sock *sk = sk_atm(vcc); 614 615 pr_debug("%s: To daemon\n", dev->name); 616 skb_queue_tail(&sk->sk_receive_queue, skb); 617 sk->sk_data_ready(sk, skb->len); 618 } else { /* Data frame, queue to protocol handlers */ 619 struct lec_arp_table *entry; 620 unsigned char *src, *dst; 621 622 atm_return(vcc, skb->truesize); 623 if (*(__be16 *) skb->data == htons(priv->lecid) || 624 !priv->lecd || !(dev->flags & IFF_UP)) { 625 /* 626 * Probably looping back, or if lecd is missing, 627 * lecd has gone down 628 */ 629 pr_debug("Ignoring frame...\n"); 630 dev_kfree_skb(skb); 631 return; 632 } 633 dst = ((struct lecdatahdr_8023 *)skb->data)->h_dest; 634 635 /* 636 * If this is a Data Direct VCC, and the VCC does not match 637 * the LE_ARP cache entry, delete the LE_ARP cache entry. 638 */ 639 spin_lock_irqsave(&priv->lec_arp_lock, flags); 640 if (lec_is_data_direct(vcc)) { 641 src = ((struct lecdatahdr_8023 *)skb->data)->h_source; 642 entry = lec_arp_find(priv, src); 643 if (entry && entry->vcc != vcc) { 644 lec_arp_remove(priv, entry); 645 lec_arp_put(entry); 646 } 647 } 648 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 649 650 if (!(dst[0] & 0x01) && /* Never filter Multi/Broadcast */ 651 !priv->is_proxy && /* Proxy wants all the packets */ 652 memcmp(dst, dev->dev_addr, dev->addr_len)) { 653 dev_kfree_skb(skb); 654 return; 655 } 656 if (!hlist_empty(&priv->lec_arp_empty_ones)) 657 lec_arp_check_empties(priv, vcc, skb); 658 skb_pull(skb, 2); /* skip lec_id */ 659 skb->protocol = eth_type_trans(skb, dev); 660 dev->stats.rx_packets++; 661 dev->stats.rx_bytes += skb->len; 662 memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data)); 663 netif_rx(skb); 664 } 665 } 666 667 static void lec_pop(struct atm_vcc *vcc, struct sk_buff *skb) 668 { 669 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 670 struct net_device *dev = skb->dev; 671 672 if (vpriv == NULL) { 673 pr_info("vpriv = NULL!?!?!?\n"); 674 return; 675 } 676 677 vpriv->old_pop(vcc, skb); 678 679 if (vpriv->xoff && atm_may_send(vcc, 0)) { 680 vpriv->xoff = 0; 681 if (netif_running(dev) && netif_queue_stopped(dev)) 682 netif_wake_queue(dev); 683 } 684 } 685 686 static int lec_vcc_attach(struct atm_vcc *vcc, void __user *arg) 687 { 688 struct lec_vcc_priv *vpriv; 689 int bytes_left; 690 struct atmlec_ioc ioc_data; 691 692 /* Lecd must be up in this case */ 693 bytes_left = copy_from_user(&ioc_data, arg, sizeof(struct atmlec_ioc)); 694 if (bytes_left != 0) 695 pr_info("copy from user failed for %d bytes\n", bytes_left); 696 if (ioc_data.dev_num < 0 || ioc_data.dev_num >= MAX_LEC_ITF || 697 !dev_lec[ioc_data.dev_num]) 698 return -EINVAL; 699 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 700 if (!vpriv) 701 return -ENOMEM; 702 vpriv->xoff = 0; 703 vpriv->old_pop = vcc->pop; 704 vcc->user_back = vpriv; 705 vcc->pop = lec_pop; 706 lec_vcc_added(netdev_priv(dev_lec[ioc_data.dev_num]), 707 &ioc_data, vcc, vcc->push); 708 vcc->proto_data = dev_lec[ioc_data.dev_num]; 709 vcc->push = lec_push; 710 return 0; 711 } 712 713 static int lec_mcast_attach(struct atm_vcc *vcc, int arg) 714 { 715 if (arg < 0 || arg >= MAX_LEC_ITF || !dev_lec[arg]) 716 return -EINVAL; 717 vcc->proto_data = dev_lec[arg]; 718 return lec_mcast_make(netdev_priv(dev_lec[arg]), vcc); 719 } 720 721 /* Initialize device. */ 722 static int lecd_attach(struct atm_vcc *vcc, int arg) 723 { 724 int i; 725 struct lec_priv *priv; 726 727 if (arg < 0) 728 i = 0; 729 else 730 i = arg; 731 if (arg >= MAX_LEC_ITF) 732 return -EINVAL; 733 if (!dev_lec[i]) { 734 int size; 735 736 size = sizeof(struct lec_priv); 737 dev_lec[i] = alloc_etherdev(size); 738 if (!dev_lec[i]) 739 return -ENOMEM; 740 dev_lec[i]->netdev_ops = &lec_netdev_ops; 741 snprintf(dev_lec[i]->name, IFNAMSIZ, "lec%d", i); 742 if (register_netdev(dev_lec[i])) { 743 free_netdev(dev_lec[i]); 744 return -EINVAL; 745 } 746 747 priv = netdev_priv(dev_lec[i]); 748 } else { 749 priv = netdev_priv(dev_lec[i]); 750 if (priv->lecd) 751 return -EADDRINUSE; 752 } 753 lec_arp_init(priv); 754 priv->itfnum = i; /* LANE2 addition */ 755 priv->lecd = vcc; 756 vcc->dev = &lecatm_dev; 757 vcc_insert_socket(sk_atm(vcc)); 758 759 vcc->proto_data = dev_lec[i]; 760 set_bit(ATM_VF_META, &vcc->flags); 761 set_bit(ATM_VF_READY, &vcc->flags); 762 763 /* Set default values to these variables */ 764 priv->maximum_unknown_frame_count = 1; 765 priv->max_unknown_frame_time = (1 * HZ); 766 priv->vcc_timeout_period = (1200 * HZ); 767 priv->max_retry_count = 1; 768 priv->aging_time = (300 * HZ); 769 priv->forward_delay_time = (15 * HZ); 770 priv->topology_change = 0; 771 priv->arp_response_time = (1 * HZ); 772 priv->flush_timeout = (4 * HZ); 773 priv->path_switching_delay = (6 * HZ); 774 775 if (dev_lec[i]->flags & IFF_UP) 776 netif_start_queue(dev_lec[i]); 777 __module_get(THIS_MODULE); 778 return i; 779 } 780 781 #ifdef CONFIG_PROC_FS 782 static const char *lec_arp_get_status_string(unsigned char status) 783 { 784 static const char *const lec_arp_status_string[] = { 785 "ESI_UNKNOWN ", 786 "ESI_ARP_PENDING ", 787 "ESI_VC_PENDING ", 788 "<Undefined> ", 789 "ESI_FLUSH_PENDING ", 790 "ESI_FORWARD_DIRECT" 791 }; 792 793 if (status > ESI_FORWARD_DIRECT) 794 status = 3; /* ESI_UNDEFINED */ 795 return lec_arp_status_string[status]; 796 } 797 798 static void lec_info(struct seq_file *seq, struct lec_arp_table *entry) 799 { 800 int i; 801 802 for (i = 0; i < ETH_ALEN; i++) 803 seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff); 804 seq_printf(seq, " "); 805 for (i = 0; i < ATM_ESA_LEN; i++) 806 seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff); 807 seq_printf(seq, " %s %4.4x", lec_arp_get_status_string(entry->status), 808 entry->flags & 0xffff); 809 if (entry->vcc) 810 seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci); 811 else 812 seq_printf(seq, " "); 813 if (entry->recv_vcc) { 814 seq_printf(seq, " %3d %3d", entry->recv_vcc->vpi, 815 entry->recv_vcc->vci); 816 } 817 seq_putc(seq, '\n'); 818 } 819 820 struct lec_state { 821 unsigned long flags; 822 struct lec_priv *locked; 823 struct hlist_node *node; 824 struct net_device *dev; 825 int itf; 826 int arp_table; 827 int misc_table; 828 }; 829 830 static void *lec_tbl_walk(struct lec_state *state, struct hlist_head *tbl, 831 loff_t *l) 832 { 833 struct hlist_node *e = state->node; 834 struct lec_arp_table *tmp; 835 836 if (!e) 837 e = tbl->first; 838 if (e == SEQ_START_TOKEN) { 839 e = tbl->first; 840 --*l; 841 } 842 843 hlist_for_each_entry_from(tmp, e, next) { 844 if (--*l < 0) 845 break; 846 } 847 state->node = e; 848 849 return (*l < 0) ? state : NULL; 850 } 851 852 static void *lec_arp_walk(struct lec_state *state, loff_t *l, 853 struct lec_priv *priv) 854 { 855 void *v = NULL; 856 int p; 857 858 for (p = state->arp_table; p < LEC_ARP_TABLE_SIZE; p++) { 859 v = lec_tbl_walk(state, &priv->lec_arp_tables[p], l); 860 if (v) 861 break; 862 } 863 state->arp_table = p; 864 return v; 865 } 866 867 static void *lec_misc_walk(struct lec_state *state, loff_t *l, 868 struct lec_priv *priv) 869 { 870 struct hlist_head *lec_misc_tables[] = { 871 &priv->lec_arp_empty_ones, 872 &priv->lec_no_forward, 873 &priv->mcast_fwds 874 }; 875 void *v = NULL; 876 int q; 877 878 for (q = state->misc_table; q < ARRAY_SIZE(lec_misc_tables); q++) { 879 v = lec_tbl_walk(state, lec_misc_tables[q], l); 880 if (v) 881 break; 882 } 883 state->misc_table = q; 884 return v; 885 } 886 887 static void *lec_priv_walk(struct lec_state *state, loff_t *l, 888 struct lec_priv *priv) 889 { 890 if (!state->locked) { 891 state->locked = priv; 892 spin_lock_irqsave(&priv->lec_arp_lock, state->flags); 893 } 894 if (!lec_arp_walk(state, l, priv) && !lec_misc_walk(state, l, priv)) { 895 spin_unlock_irqrestore(&priv->lec_arp_lock, state->flags); 896 state->locked = NULL; 897 /* Partial state reset for the next time we get called */ 898 state->arp_table = state->misc_table = 0; 899 } 900 return state->locked; 901 } 902 903 static void *lec_itf_walk(struct lec_state *state, loff_t *l) 904 { 905 struct net_device *dev; 906 void *v; 907 908 dev = state->dev ? state->dev : dev_lec[state->itf]; 909 v = (dev && netdev_priv(dev)) ? 910 lec_priv_walk(state, l, netdev_priv(dev)) : NULL; 911 if (!v && dev) { 912 dev_put(dev); 913 /* Partial state reset for the next time we get called */ 914 dev = NULL; 915 } 916 state->dev = dev; 917 return v; 918 } 919 920 static void *lec_get_idx(struct lec_state *state, loff_t l) 921 { 922 void *v = NULL; 923 924 for (; state->itf < MAX_LEC_ITF; state->itf++) { 925 v = lec_itf_walk(state, &l); 926 if (v) 927 break; 928 } 929 return v; 930 } 931 932 static void *lec_seq_start(struct seq_file *seq, loff_t *pos) 933 { 934 struct lec_state *state = seq->private; 935 936 state->itf = 0; 937 state->dev = NULL; 938 state->locked = NULL; 939 state->arp_table = 0; 940 state->misc_table = 0; 941 state->node = SEQ_START_TOKEN; 942 943 return *pos ? lec_get_idx(state, *pos) : SEQ_START_TOKEN; 944 } 945 946 static void lec_seq_stop(struct seq_file *seq, void *v) 947 { 948 struct lec_state *state = seq->private; 949 950 if (state->dev) { 951 spin_unlock_irqrestore(&state->locked->lec_arp_lock, 952 state->flags); 953 dev_put(state->dev); 954 } 955 } 956 957 static void *lec_seq_next(struct seq_file *seq, void *v, loff_t *pos) 958 { 959 struct lec_state *state = seq->private; 960 961 v = lec_get_idx(state, 1); 962 *pos += !!PTR_ERR(v); 963 return v; 964 } 965 966 static int lec_seq_show(struct seq_file *seq, void *v) 967 { 968 static const char lec_banner[] = 969 "Itf MAC ATM destination" 970 " Status Flags " 971 "VPI/VCI Recv VPI/VCI\n"; 972 973 if (v == SEQ_START_TOKEN) 974 seq_puts(seq, lec_banner); 975 else { 976 struct lec_state *state = seq->private; 977 struct net_device *dev = state->dev; 978 struct lec_arp_table *entry = hlist_entry(state->node, 979 struct lec_arp_table, 980 next); 981 982 seq_printf(seq, "%s ", dev->name); 983 lec_info(seq, entry); 984 } 985 return 0; 986 } 987 988 static const struct seq_operations lec_seq_ops = { 989 .start = lec_seq_start, 990 .next = lec_seq_next, 991 .stop = lec_seq_stop, 992 .show = lec_seq_show, 993 }; 994 995 static int lec_seq_open(struct inode *inode, struct file *file) 996 { 997 return seq_open_private(file, &lec_seq_ops, sizeof(struct lec_state)); 998 } 999 1000 static const struct file_operations lec_seq_fops = { 1001 .owner = THIS_MODULE, 1002 .open = lec_seq_open, 1003 .read = seq_read, 1004 .llseek = seq_lseek, 1005 .release = seq_release_private, 1006 }; 1007 #endif 1008 1009 static int lane_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg) 1010 { 1011 struct atm_vcc *vcc = ATM_SD(sock); 1012 int err = 0; 1013 1014 switch (cmd) { 1015 case ATMLEC_CTRL: 1016 case ATMLEC_MCAST: 1017 case ATMLEC_DATA: 1018 if (!capable(CAP_NET_ADMIN)) 1019 return -EPERM; 1020 break; 1021 default: 1022 return -ENOIOCTLCMD; 1023 } 1024 1025 switch (cmd) { 1026 case ATMLEC_CTRL: 1027 err = lecd_attach(vcc, (int)arg); 1028 if (err >= 0) 1029 sock->state = SS_CONNECTED; 1030 break; 1031 case ATMLEC_MCAST: 1032 err = lec_mcast_attach(vcc, (int)arg); 1033 break; 1034 case ATMLEC_DATA: 1035 err = lec_vcc_attach(vcc, (void __user *)arg); 1036 break; 1037 } 1038 1039 return err; 1040 } 1041 1042 static struct atm_ioctl lane_ioctl_ops = { 1043 .owner = THIS_MODULE, 1044 .ioctl = lane_ioctl, 1045 }; 1046 1047 static int __init lane_module_init(void) 1048 { 1049 #ifdef CONFIG_PROC_FS 1050 struct proc_dir_entry *p; 1051 1052 p = proc_create("lec", S_IRUGO, atm_proc_root, &lec_seq_fops); 1053 if (!p) { 1054 pr_err("Unable to initialize /proc/net/atm/lec\n"); 1055 return -ENOMEM; 1056 } 1057 #endif 1058 1059 register_atm_ioctl(&lane_ioctl_ops); 1060 pr_info("lec.c: initialized\n"); 1061 return 0; 1062 } 1063 1064 static void __exit lane_module_cleanup(void) 1065 { 1066 int i; 1067 1068 remove_proc_entry("lec", atm_proc_root); 1069 1070 deregister_atm_ioctl(&lane_ioctl_ops); 1071 1072 for (i = 0; i < MAX_LEC_ITF; i++) { 1073 if (dev_lec[i] != NULL) { 1074 unregister_netdev(dev_lec[i]); 1075 free_netdev(dev_lec[i]); 1076 dev_lec[i] = NULL; 1077 } 1078 } 1079 } 1080 1081 module_init(lane_module_init); 1082 module_exit(lane_module_cleanup); 1083 1084 /* 1085 * LANE2: 3.1.3, LE_RESOLVE.request 1086 * Non force allocates memory and fills in *tlvs, fills in *sizeoftlvs. 1087 * If sizeoftlvs == NULL the default TLVs associated with with this 1088 * lec will be used. 1089 * If dst_mac == NULL, targetless LE_ARP will be sent 1090 */ 1091 static int lane2_resolve(struct net_device *dev, const u8 *dst_mac, int force, 1092 u8 **tlvs, u32 *sizeoftlvs) 1093 { 1094 unsigned long flags; 1095 struct lec_priv *priv = netdev_priv(dev); 1096 struct lec_arp_table *table; 1097 struct sk_buff *skb; 1098 int retval; 1099 1100 if (force == 0) { 1101 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1102 table = lec_arp_find(priv, dst_mac); 1103 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1104 if (table == NULL) 1105 return -1; 1106 1107 *tlvs = kmemdup(table->tlvs, table->sizeoftlvs, GFP_ATOMIC); 1108 if (*tlvs == NULL) 1109 return -1; 1110 1111 *sizeoftlvs = table->sizeoftlvs; 1112 1113 return 0; 1114 } 1115 1116 if (sizeoftlvs == NULL) 1117 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, NULL); 1118 1119 else { 1120 skb = alloc_skb(*sizeoftlvs, GFP_ATOMIC); 1121 if (skb == NULL) 1122 return -1; 1123 skb->len = *sizeoftlvs; 1124 skb_copy_to_linear_data(skb, *tlvs, *sizeoftlvs); 1125 retval = send_to_lecd(priv, l_arp_xmt, dst_mac, NULL, skb); 1126 } 1127 return retval; 1128 } 1129 1130 /* 1131 * LANE2: 3.1.4, LE_ASSOCIATE.request 1132 * Associate the *tlvs with the *lan_dst address. 1133 * Will overwrite any previous association 1134 * Returns 1 for success, 0 for failure (out of memory) 1135 * 1136 */ 1137 static int lane2_associate_req(struct net_device *dev, const u8 *lan_dst, 1138 const u8 *tlvs, u32 sizeoftlvs) 1139 { 1140 int retval; 1141 struct sk_buff *skb; 1142 struct lec_priv *priv = netdev_priv(dev); 1143 1144 if (!ether_addr_equal(lan_dst, dev->dev_addr)) 1145 return 0; /* not our mac address */ 1146 1147 kfree(priv->tlvs); /* NULL if there was no previous association */ 1148 1149 priv->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1150 if (priv->tlvs == NULL) 1151 return 0; 1152 priv->sizeoftlvs = sizeoftlvs; 1153 1154 skb = alloc_skb(sizeoftlvs, GFP_ATOMIC); 1155 if (skb == NULL) 1156 return 0; 1157 skb->len = sizeoftlvs; 1158 skb_copy_to_linear_data(skb, tlvs, sizeoftlvs); 1159 retval = send_to_lecd(priv, l_associate_req, NULL, NULL, skb); 1160 if (retval != 0) 1161 pr_info("lec.c: lane2_associate_req() failed\n"); 1162 /* 1163 * If the previous association has changed we must 1164 * somehow notify other LANE entities about the change 1165 */ 1166 return 1; 1167 } 1168 1169 /* 1170 * LANE2: 3.1.5, LE_ASSOCIATE.indication 1171 * 1172 */ 1173 static void lane2_associate_ind(struct net_device *dev, const u8 *mac_addr, 1174 const u8 *tlvs, u32 sizeoftlvs) 1175 { 1176 #if 0 1177 int i = 0; 1178 #endif 1179 struct lec_priv *priv = netdev_priv(dev); 1180 #if 0 /* 1181 * Why have the TLVs in LE_ARP entries 1182 * since we do not use them? When you 1183 * uncomment this code, make sure the 1184 * TLVs get freed when entry is killed 1185 */ 1186 struct lec_arp_table *entry = lec_arp_find(priv, mac_addr); 1187 1188 if (entry == NULL) 1189 return; /* should not happen */ 1190 1191 kfree(entry->tlvs); 1192 1193 entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL); 1194 if (entry->tlvs == NULL) 1195 return; 1196 entry->sizeoftlvs = sizeoftlvs; 1197 #endif 1198 #if 0 1199 pr_info("\n"); 1200 pr_info("dump of tlvs, sizeoftlvs=%d\n", sizeoftlvs); 1201 while (i < sizeoftlvs) 1202 pr_cont("%02x ", tlvs[i++]); 1203 1204 pr_cont("\n"); 1205 #endif 1206 1207 /* tell MPOA about the TLVs we saw */ 1208 if (priv->lane2_ops && priv->lane2_ops->associate_indicator) { 1209 priv->lane2_ops->associate_indicator(dev, mac_addr, 1210 tlvs, sizeoftlvs); 1211 } 1212 } 1213 1214 /* 1215 * Here starts what used to lec_arpc.c 1216 * 1217 * lec_arpc.c was added here when making 1218 * lane client modular. October 1997 1219 */ 1220 1221 #include <linux/types.h> 1222 #include <linux/timer.h> 1223 #include <linux/param.h> 1224 #include <linux/atomic.h> 1225 #include <linux/inetdevice.h> 1226 #include <net/route.h> 1227 1228 #if 0 1229 #define pr_debug(format, args...) 1230 /* 1231 #define pr_debug printk 1232 */ 1233 #endif 1234 #define DEBUG_ARP_TABLE 0 1235 1236 #define LEC_ARP_REFRESH_INTERVAL (3*HZ) 1237 1238 static void lec_arp_check_expire(struct work_struct *work); 1239 static void lec_arp_expire_arp(unsigned long data); 1240 1241 /* 1242 * Arp table funcs 1243 */ 1244 1245 #define HASH(ch) (ch & (LEC_ARP_TABLE_SIZE - 1)) 1246 1247 /* 1248 * Initialization of arp-cache 1249 */ 1250 static void lec_arp_init(struct lec_priv *priv) 1251 { 1252 unsigned short i; 1253 1254 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 1255 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1256 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1257 INIT_HLIST_HEAD(&priv->lec_no_forward); 1258 INIT_HLIST_HEAD(&priv->mcast_fwds); 1259 spin_lock_init(&priv->lec_arp_lock); 1260 INIT_DELAYED_WORK(&priv->lec_arp_work, lec_arp_check_expire); 1261 schedule_delayed_work(&priv->lec_arp_work, LEC_ARP_REFRESH_INTERVAL); 1262 } 1263 1264 static void lec_arp_clear_vccs(struct lec_arp_table *entry) 1265 { 1266 if (entry->vcc) { 1267 struct atm_vcc *vcc = entry->vcc; 1268 struct lec_vcc_priv *vpriv = LEC_VCC_PRIV(vcc); 1269 struct net_device *dev = (struct net_device *)vcc->proto_data; 1270 1271 vcc->pop = vpriv->old_pop; 1272 if (vpriv->xoff) 1273 netif_wake_queue(dev); 1274 kfree(vpriv); 1275 vcc->user_back = NULL; 1276 vcc->push = entry->old_push; 1277 vcc_release_async(vcc, -EPIPE); 1278 entry->vcc = NULL; 1279 } 1280 if (entry->recv_vcc) { 1281 entry->recv_vcc->push = entry->old_recv_push; 1282 vcc_release_async(entry->recv_vcc, -EPIPE); 1283 entry->recv_vcc = NULL; 1284 } 1285 } 1286 1287 /* 1288 * Insert entry to lec_arp_table 1289 * LANE2: Add to the end of the list to satisfy 8.1.13 1290 */ 1291 static inline void 1292 lec_arp_add(struct lec_priv *priv, struct lec_arp_table *entry) 1293 { 1294 struct hlist_head *tmp; 1295 1296 tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])]; 1297 hlist_add_head(&entry->next, tmp); 1298 1299 pr_debug("Added entry:%pM\n", entry->mac_addr); 1300 } 1301 1302 /* 1303 * Remove entry from lec_arp_table 1304 */ 1305 static int 1306 lec_arp_remove(struct lec_priv *priv, struct lec_arp_table *to_remove) 1307 { 1308 struct hlist_node *node; 1309 struct lec_arp_table *entry; 1310 int i, remove_vcc = 1; 1311 1312 if (!to_remove) 1313 return -1; 1314 1315 hlist_del(&to_remove->next); 1316 del_timer(&to_remove->timer); 1317 1318 /* 1319 * If this is the only MAC connected to this VCC, 1320 * also tear down the VCC 1321 */ 1322 if (to_remove->status >= ESI_FLUSH_PENDING) { 1323 /* 1324 * ESI_FLUSH_PENDING, ESI_FORWARD_DIRECT 1325 */ 1326 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1327 hlist_for_each_entry(entry, node, 1328 &priv->lec_arp_tables[i], next) { 1329 if (memcmp(to_remove->atm_addr, 1330 entry->atm_addr, ATM_ESA_LEN) == 0) { 1331 remove_vcc = 0; 1332 break; 1333 } 1334 } 1335 } 1336 if (remove_vcc) 1337 lec_arp_clear_vccs(to_remove); 1338 } 1339 skb_queue_purge(&to_remove->tx_wait); /* FIXME: good place for this? */ 1340 1341 pr_debug("Removed entry:%pM\n", to_remove->mac_addr); 1342 return 0; 1343 } 1344 1345 #if DEBUG_ARP_TABLE 1346 static const char *get_status_string(unsigned char st) 1347 { 1348 switch (st) { 1349 case ESI_UNKNOWN: 1350 return "ESI_UNKNOWN"; 1351 case ESI_ARP_PENDING: 1352 return "ESI_ARP_PENDING"; 1353 case ESI_VC_PENDING: 1354 return "ESI_VC_PENDING"; 1355 case ESI_FLUSH_PENDING: 1356 return "ESI_FLUSH_PENDING"; 1357 case ESI_FORWARD_DIRECT: 1358 return "ESI_FORWARD_DIRECT"; 1359 } 1360 return "<UNKNOWN>"; 1361 } 1362 1363 static void dump_arp_table(struct lec_priv *priv) 1364 { 1365 struct hlist_node *node; 1366 struct lec_arp_table *rulla; 1367 char buf[256]; 1368 int i, j, offset; 1369 1370 pr_info("Dump %p:\n", priv); 1371 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1372 hlist_for_each_entry(rulla, node, 1373 &priv->lec_arp_tables[i], next) { 1374 offset = 0; 1375 offset += sprintf(buf, "%d: %p\n", i, rulla); 1376 offset += sprintf(buf + offset, "Mac: %pM", 1377 rulla->mac_addr); 1378 offset += sprintf(buf + offset, " Atm:"); 1379 for (j = 0; j < ATM_ESA_LEN; j++) { 1380 offset += sprintf(buf + offset, 1381 "%2.2x ", 1382 rulla->atm_addr[j] & 0xff); 1383 } 1384 offset += sprintf(buf + offset, 1385 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1386 rulla->vcc ? rulla->vcc->vpi : 0, 1387 rulla->vcc ? rulla->vcc->vci : 0, 1388 rulla->recv_vcc ? rulla->recv_vcc-> 1389 vpi : 0, 1390 rulla->recv_vcc ? rulla->recv_vcc-> 1391 vci : 0, rulla->last_used, 1392 rulla->timestamp, rulla->no_tries); 1393 offset += 1394 sprintf(buf + offset, 1395 "Flags:%x, Packets_flooded:%x, Status: %s ", 1396 rulla->flags, rulla->packets_flooded, 1397 get_status_string(rulla->status)); 1398 pr_info("%s\n", buf); 1399 } 1400 } 1401 1402 if (!hlist_empty(&priv->lec_no_forward)) 1403 pr_info("No forward\n"); 1404 hlist_for_each_entry(rulla, node, &priv->lec_no_forward, next) { 1405 offset = 0; 1406 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1407 offset += sprintf(buf + offset, " Atm:"); 1408 for (j = 0; j < ATM_ESA_LEN; j++) { 1409 offset += sprintf(buf + offset, "%2.2x ", 1410 rulla->atm_addr[j] & 0xff); 1411 } 1412 offset += sprintf(buf + offset, 1413 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1414 rulla->vcc ? rulla->vcc->vpi : 0, 1415 rulla->vcc ? rulla->vcc->vci : 0, 1416 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1417 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1418 rulla->last_used, 1419 rulla->timestamp, rulla->no_tries); 1420 offset += sprintf(buf + offset, 1421 "Flags:%x, Packets_flooded:%x, Status: %s ", 1422 rulla->flags, rulla->packets_flooded, 1423 get_status_string(rulla->status)); 1424 pr_info("%s\n", buf); 1425 } 1426 1427 if (!hlist_empty(&priv->lec_arp_empty_ones)) 1428 pr_info("Empty ones\n"); 1429 hlist_for_each_entry(rulla, node, &priv->lec_arp_empty_ones, next) { 1430 offset = 0; 1431 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1432 offset += sprintf(buf + offset, " Atm:"); 1433 for (j = 0; j < ATM_ESA_LEN; j++) { 1434 offset += sprintf(buf + offset, "%2.2x ", 1435 rulla->atm_addr[j] & 0xff); 1436 } 1437 offset += sprintf(buf + offset, 1438 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1439 rulla->vcc ? rulla->vcc->vpi : 0, 1440 rulla->vcc ? rulla->vcc->vci : 0, 1441 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1442 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1443 rulla->last_used, 1444 rulla->timestamp, rulla->no_tries); 1445 offset += sprintf(buf + offset, 1446 "Flags:%x, Packets_flooded:%x, Status: %s ", 1447 rulla->flags, rulla->packets_flooded, 1448 get_status_string(rulla->status)); 1449 pr_info("%s", buf); 1450 } 1451 1452 if (!hlist_empty(&priv->mcast_fwds)) 1453 pr_info("Multicast Forward VCCs\n"); 1454 hlist_for_each_entry(rulla, node, &priv->mcast_fwds, next) { 1455 offset = 0; 1456 offset += sprintf(buf + offset, "Mac: %pM", rulla->mac_addr); 1457 offset += sprintf(buf + offset, " Atm:"); 1458 for (j = 0; j < ATM_ESA_LEN; j++) { 1459 offset += sprintf(buf + offset, "%2.2x ", 1460 rulla->atm_addr[j] & 0xff); 1461 } 1462 offset += sprintf(buf + offset, 1463 "Vcc vpi:%d vci:%d, Recv_vcc vpi:%d vci:%d Last_used:%lx, Timestamp:%lx, No_tries:%d ", 1464 rulla->vcc ? rulla->vcc->vpi : 0, 1465 rulla->vcc ? rulla->vcc->vci : 0, 1466 rulla->recv_vcc ? rulla->recv_vcc->vpi : 0, 1467 rulla->recv_vcc ? rulla->recv_vcc->vci : 0, 1468 rulla->last_used, 1469 rulla->timestamp, rulla->no_tries); 1470 offset += sprintf(buf + offset, 1471 "Flags:%x, Packets_flooded:%x, Status: %s ", 1472 rulla->flags, rulla->packets_flooded, 1473 get_status_string(rulla->status)); 1474 pr_info("%s\n", buf); 1475 } 1476 1477 } 1478 #else 1479 #define dump_arp_table(priv) do { } while (0) 1480 #endif 1481 1482 /* 1483 * Destruction of arp-cache 1484 */ 1485 static void lec_arp_destroy(struct lec_priv *priv) 1486 { 1487 unsigned long flags; 1488 struct hlist_node *node, *next; 1489 struct lec_arp_table *entry; 1490 int i; 1491 1492 cancel_delayed_work_sync(&priv->lec_arp_work); 1493 1494 /* 1495 * Remove all entries 1496 */ 1497 1498 spin_lock_irqsave(&priv->lec_arp_lock, flags); 1499 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1500 hlist_for_each_entry_safe(entry, node, next, 1501 &priv->lec_arp_tables[i], next) { 1502 lec_arp_remove(priv, entry); 1503 lec_arp_put(entry); 1504 } 1505 INIT_HLIST_HEAD(&priv->lec_arp_tables[i]); 1506 } 1507 1508 hlist_for_each_entry_safe(entry, node, next, 1509 &priv->lec_arp_empty_ones, next) { 1510 del_timer_sync(&entry->timer); 1511 lec_arp_clear_vccs(entry); 1512 hlist_del(&entry->next); 1513 lec_arp_put(entry); 1514 } 1515 INIT_HLIST_HEAD(&priv->lec_arp_empty_ones); 1516 1517 hlist_for_each_entry_safe(entry, node, next, 1518 &priv->lec_no_forward, next) { 1519 del_timer_sync(&entry->timer); 1520 lec_arp_clear_vccs(entry); 1521 hlist_del(&entry->next); 1522 lec_arp_put(entry); 1523 } 1524 INIT_HLIST_HEAD(&priv->lec_no_forward); 1525 1526 hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) { 1527 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 1528 lec_arp_clear_vccs(entry); 1529 hlist_del(&entry->next); 1530 lec_arp_put(entry); 1531 } 1532 INIT_HLIST_HEAD(&priv->mcast_fwds); 1533 priv->mcast_vcc = NULL; 1534 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1535 } 1536 1537 /* 1538 * Find entry by mac_address 1539 */ 1540 static struct lec_arp_table *lec_arp_find(struct lec_priv *priv, 1541 const unsigned char *mac_addr) 1542 { 1543 struct hlist_node *node; 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, node, 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 memcpy(to_return->mac_addr, mac_addr, ETH_ALEN); 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 = (struct lec_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 *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, node, 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 *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, node, 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 *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, node, 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 memcpy(entry->mac_addr, mac_addr, ETH_ALEN); 1890 entry->last_used = jiffies; 1891 lec_arp_add(priv, entry); 1892 } 1893 if (remoteflag) 1894 entry->flags |= LEC_REMOTE_FLAG; 1895 else 1896 entry->flags &= ~LEC_REMOTE_FLAG; 1897 pr_debug("After update\n"); 1898 dump_arp_table(priv); 1899 goto out; 1900 } 1901 } 1902 } 1903 1904 entry = lec_arp_find(priv, mac_addr); 1905 if (!entry) { 1906 entry = make_entry(priv, mac_addr); 1907 if (!entry) 1908 goto out; 1909 entry->status = ESI_UNKNOWN; 1910 lec_arp_add(priv, entry); 1911 /* Temporary, changes before end of function */ 1912 } 1913 memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN); 1914 del_timer(&entry->timer); 1915 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 1916 hlist_for_each_entry(tmp, node, 1917 &priv->lec_arp_tables[i], next) { 1918 if (entry != tmp && 1919 !memcmp(tmp->atm_addr, atm_addr, ATM_ESA_LEN)) { 1920 /* Vcc to this host exists */ 1921 if (tmp->status > ESI_VC_PENDING) { 1922 /* 1923 * ESI_FLUSH_PENDING, 1924 * ESI_FORWARD_DIRECT 1925 */ 1926 entry->vcc = tmp->vcc; 1927 entry->old_push = tmp->old_push; 1928 } 1929 entry->status = tmp->status; 1930 break; 1931 } 1932 } 1933 } 1934 if (remoteflag) 1935 entry->flags |= LEC_REMOTE_FLAG; 1936 else 1937 entry->flags &= ~LEC_REMOTE_FLAG; 1938 if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) { 1939 entry->status = ESI_VC_PENDING; 1940 send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL); 1941 } 1942 pr_debug("After update2\n"); 1943 dump_arp_table(priv); 1944 out: 1945 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 1946 } 1947 1948 /* 1949 * Notifies: Vcc setup ready 1950 */ 1951 static void 1952 lec_vcc_added(struct lec_priv *priv, const struct atmlec_ioc *ioc_data, 1953 struct atm_vcc *vcc, 1954 void (*old_push) (struct atm_vcc *vcc, struct sk_buff *skb)) 1955 { 1956 unsigned long flags; 1957 struct hlist_node *node; 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 memset(entry->mac_addr, 0, ETH_ALEN); 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, node, 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 memset(entry->mac_addr, 0, ETH_ALEN); 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 hlist_node *node; 2105 struct lec_arp_table *entry; 2106 int i; 2107 2108 pr_debug("%lx\n", tran_id); 2109 restart: 2110 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2111 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2112 hlist_for_each_entry(entry, node, 2113 &priv->lec_arp_tables[i], next) { 2114 if (entry->flush_tran_id == tran_id && 2115 entry->status == ESI_FLUSH_PENDING) { 2116 struct sk_buff *skb; 2117 struct atm_vcc *vcc = entry->vcc; 2118 2119 lec_arp_hold(entry); 2120 spin_unlock_irqrestore(&priv->lec_arp_lock, 2121 flags); 2122 while ((skb = skb_dequeue(&entry->tx_wait))) 2123 lec_send(vcc, skb); 2124 entry->last_used = jiffies; 2125 entry->status = ESI_FORWARD_DIRECT; 2126 lec_arp_put(entry); 2127 pr_debug("LEC_ARP: Flushed\n"); 2128 goto restart; 2129 } 2130 } 2131 } 2132 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2133 dump_arp_table(priv); 2134 } 2135 2136 static void 2137 lec_set_flush_tran_id(struct lec_priv *priv, 2138 const unsigned char *atm_addr, unsigned long tran_id) 2139 { 2140 unsigned long flags; 2141 struct hlist_node *node; 2142 struct lec_arp_table *entry; 2143 int i; 2144 2145 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2146 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) 2147 hlist_for_each_entry(entry, node, 2148 &priv->lec_arp_tables[i], next) { 2149 if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) { 2150 entry->flush_tran_id = tran_id; 2151 pr_debug("Set flush transaction id to %lx for %p\n", 2152 tran_id, entry); 2153 } 2154 } 2155 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2156 } 2157 2158 static int lec_mcast_make(struct lec_priv *priv, struct atm_vcc *vcc) 2159 { 2160 unsigned long flags; 2161 unsigned char mac_addr[] = { 2162 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 2163 }; 2164 struct lec_arp_table *to_add; 2165 struct lec_vcc_priv *vpriv; 2166 int err = 0; 2167 2168 vpriv = kmalloc(sizeof(struct lec_vcc_priv), GFP_KERNEL); 2169 if (!vpriv) 2170 return -ENOMEM; 2171 vpriv->xoff = 0; 2172 vpriv->old_pop = vcc->pop; 2173 vcc->user_back = vpriv; 2174 vcc->pop = lec_pop; 2175 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2176 to_add = make_entry(priv, mac_addr); 2177 if (!to_add) { 2178 vcc->pop = vpriv->old_pop; 2179 kfree(vpriv); 2180 err = -ENOMEM; 2181 goto out; 2182 } 2183 memcpy(to_add->atm_addr, vcc->remote.sas_addr.prv, ATM_ESA_LEN); 2184 to_add->status = ESI_FORWARD_DIRECT; 2185 to_add->flags |= LEC_PERMANENT_FLAG; 2186 to_add->vcc = vcc; 2187 to_add->old_push = vcc->push; 2188 vcc->push = lec_push; 2189 priv->mcast_vcc = vcc; 2190 lec_arp_add(priv, to_add); 2191 out: 2192 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2193 return err; 2194 } 2195 2196 static void lec_vcc_close(struct lec_priv *priv, struct atm_vcc *vcc) 2197 { 2198 unsigned long flags; 2199 struct hlist_node *node, *next; 2200 struct lec_arp_table *entry; 2201 int i; 2202 2203 pr_debug("LEC_ARP: lec_vcc_close vpi:%d vci:%d\n", vcc->vpi, vcc->vci); 2204 dump_arp_table(priv); 2205 2206 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2207 2208 for (i = 0; i < LEC_ARP_TABLE_SIZE; i++) { 2209 hlist_for_each_entry_safe(entry, node, next, 2210 &priv->lec_arp_tables[i], next) { 2211 if (vcc == entry->vcc) { 2212 lec_arp_remove(priv, entry); 2213 lec_arp_put(entry); 2214 if (priv->mcast_vcc == vcc) 2215 priv->mcast_vcc = NULL; 2216 } 2217 } 2218 } 2219 2220 hlist_for_each_entry_safe(entry, node, next, 2221 &priv->lec_arp_empty_ones, next) { 2222 if (entry->vcc == vcc) { 2223 lec_arp_clear_vccs(entry); 2224 del_timer(&entry->timer); 2225 hlist_del(&entry->next); 2226 lec_arp_put(entry); 2227 } 2228 } 2229 2230 hlist_for_each_entry_safe(entry, node, next, 2231 &priv->lec_no_forward, next) { 2232 if (entry->recv_vcc == vcc) { 2233 lec_arp_clear_vccs(entry); 2234 del_timer(&entry->timer); 2235 hlist_del(&entry->next); 2236 lec_arp_put(entry); 2237 } 2238 } 2239 2240 hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) { 2241 if (entry->recv_vcc == vcc) { 2242 lec_arp_clear_vccs(entry); 2243 /* No timer, LANEv2 7.1.20 and 2.3.5.3 */ 2244 hlist_del(&entry->next); 2245 lec_arp_put(entry); 2246 } 2247 } 2248 2249 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2250 dump_arp_table(priv); 2251 } 2252 2253 static void 2254 lec_arp_check_empties(struct lec_priv *priv, 2255 struct atm_vcc *vcc, struct sk_buff *skb) 2256 { 2257 unsigned long flags; 2258 struct hlist_node *node, *next; 2259 struct lec_arp_table *entry, *tmp; 2260 struct lecdatahdr_8023 *hdr = (struct lecdatahdr_8023 *)skb->data; 2261 unsigned char *src = hdr->h_source; 2262 2263 spin_lock_irqsave(&priv->lec_arp_lock, flags); 2264 hlist_for_each_entry_safe(entry, node, next, 2265 &priv->lec_arp_empty_ones, next) { 2266 if (vcc == entry->vcc) { 2267 del_timer(&entry->timer); 2268 memcpy(entry->mac_addr, src, ETH_ALEN); 2269 entry->status = ESI_FORWARD_DIRECT; 2270 entry->last_used = jiffies; 2271 /* We might have got an entry */ 2272 tmp = lec_arp_find(priv, src); 2273 if (tmp) { 2274 lec_arp_remove(priv, tmp); 2275 lec_arp_put(tmp); 2276 } 2277 hlist_del(&entry->next); 2278 lec_arp_add(priv, entry); 2279 goto out; 2280 } 2281 } 2282 pr_debug("LEC_ARP: Arp_check_empties: entry not found!\n"); 2283 out: 2284 spin_unlock_irqrestore(&priv->lec_arp_lock, flags); 2285 } 2286 2287 MODULE_LICENSE("GPL"); 2288