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