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