--- linux-2.6.9/net/atm/Makefile 2004-10-18 23:53:21.000000000 +0200 +++ linux-2.6.10/net/atm/Makefile 2005-01-04 19:52:12.000000000 +0100 @@ -16,3 +16,7 @@ obj-$(CONFIG_ATM_LANE) += lec.o obj-$(CONFIG_ATM_MPOA) += mpoa.o obj-$(CONFIG_PPPOATM) += pppoatm.o + + +obj-$(CONFIG_ATM_RT2684) += rt2684.o +atm-$(subst m,y,$(ATM_RT2684)) += ipcommon.o --- linux-2.6.9/net/atm/rt2684.c 1970-01-01 01:00:00.000000000 +0100 +++ linux-2.6.10/net/atm/rt2684.c 2005-01-05 14:17:29.000000000 +0100 @@ -0,0 +1,649 @@ +/* +Experimental IP netdevice using ATM AAL5 as underlying carrier +(RFC1483 obsoleted by RFC2684) +Author: Marcell GAL, 2000, XDSL Ltd, Hungary +2005 (c) Castet Matthieu (castet.matthieu@fre.fr) +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +#include "common.h" +#include "ipcommon.h" + + +//#define SKB_DEBUG + +/* dhcpclient from isc only know ethernet :( */ +//#define DHCP_HACK + +#ifdef DEBUG +#define DPRINTK(format, args...) printk(KERN_DEBUG "rt2684: " format, ##args) +#else +#define DPRINTK(format, args...) +#endif + +#ifdef SKB_DEBUG +static void skb_debug(const struct sk_buff *skb) +{ +#define NUM2PRINT 50 + char buf[NUM2PRINT * 3 + 1]; /* 3 chars per byte */ + int i = 0; + for (i = 0; i < skb->len && i < NUM2PRINT; i++) { + sprintf(buf + i * 3, "%2.2x ", 0xff & skb->data[i]); + } + printk(KERN_DEBUG "rt2684: skb: %s\n", buf); +} +#else +#define skb_debug(skb) do {} while (0) +#endif + +static unsigned char llc_oui[] = + { 0xAA, 0xAA, 0x03, 0x00, 0x00, 0x00 }; +#ifdef DHCP_HACK +static unsigned char broadcast[] = + { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; +static dhcp_hack = 0; +#endif + +enum rt2684_encaps { + e_vc = BR2684_ENCAPS_VC, + e_llc = BR2684_ENCAPS_LLC, +}; + +struct rt2684_vcc { + struct atm_vcc *atmvcc; + struct net_device *device; + /* keep old push,pop functions for chaining */ + void (*old_push)(struct atm_vcc *vcc,struct sk_buff *skb); + /* void (*old_pop)(struct atm_vcc *vcc,struct sk_buff *skb); */ + enum rt2684_encaps encaps; + struct list_head brvccs; +}; + +struct rt2684_dev { + struct net_device *net_dev; + struct list_head rt2684_devs; + int number; + struct list_head brvccs; /* one device <=> one vcc (before xmas) */ + struct net_device_stats stats; + int mac_was_set; +}; + +/* + * This lock should be held for writing any time the list of devices or + * their attached vcc's could be altered. It should be held for reading + * any time these are being queried. Note that we sometimes need to + * do read-locking under interrupt context, so write locking must block + * the current CPU's interrupts + */ +static rwlock_t devs_lock = RW_LOCK_UNLOCKED; + +static LIST_HEAD(rt2684_devs); + +static inline struct rt2684_dev *RTPRIV(const struct net_device *net_dev) +{ + return (struct rt2684_dev *) net_dev->priv; +} + +static inline struct net_device *list_entry_brdev(const struct list_head *le) +{ + return list_entry(le, struct rt2684_dev, rt2684_devs)->net_dev; +} + +static inline struct rt2684_vcc *RT2684_VCC(const struct atm_vcc *atmvcc) +{ + return (struct rt2684_vcc *) (atmvcc->user_back); +} + +static inline struct rt2684_vcc *list_entry_brvcc(const struct list_head *le) +{ + return list_entry(le, struct rt2684_vcc, brvccs); +} + +/* Caller should hold read_lock(&devs_lock) */ +static struct net_device *rt2684_find_dev(const struct br2684_if_spec *s) +{ + struct list_head *lh; + struct net_device *net_dev; + switch (s->method) { + case BR2684_FIND_BYNUM: + list_for_each(lh, &rt2684_devs) { + net_dev = list_entry_brdev(lh); + if (RTPRIV(net_dev)->number == s->spec.devnum) + return net_dev; + } + break; + case BR2684_FIND_BYIFNAME: + list_for_each(lh, &rt2684_devs) { + net_dev = list_entry_brdev(lh); + if (!strncmp(net_dev->name, s->spec.ifname, IFNAMSIZ)) + return net_dev; + } + break; + } + return NULL; +} + +/* + * Send a packet out a particular vcc. Not to useful right now, but paves + * the way for multiple vcc's per itf. Returns true if we can send, + * otherwise false + */ +static int rt2684_xmit_vcc(struct sk_buff *skb, struct rt2684_dev *brdev, + struct rt2684_vcc *brvcc) +{ + struct atm_vcc *atmvcc; + if (brvcc->encaps == e_llc) { + void *here = skb_push(skb, RFC1483LLC_LEN); + memcpy(here, llc_oui, sizeof(llc_oui)); + ((u16 *) here)[3] = skb->protocol; + } + +#ifdef DHCP_HACK + //dhcp hack... + if (!memcmp(skb->data,broadcast, 6) && + htons(*(uint16_t*)(skb->data+34)) == 0x44) { + printk("dhcp hack send\n"); + skb_pull(skb, ETH_HLEN); + dhcp_hack = 1; + } +#endif + if (skb->protocol != htons(ETH_P_IP)) { + printk("sending no ip pacquet : %d\n", skb->protocol); + } + skb_debug(skb); + + ATM_SKB(skb)->vcc = atmvcc = brvcc->atmvcc; + DPRINTK("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, atmvcc, atmvcc->dev); + if (!atm_may_send(atmvcc, skb->truesize)) { + /* we free this here for now, because we cannot know in a higher + layer whether the skb point it supplied wasn't freed yet. + now, it always is. + */ + dev_kfree_skb(skb); + return 0; + } + atomic_add(skb->truesize, &atmvcc->sk->sk_wmem_alloc); + ATM_SKB(skb)->atm_options = atmvcc->atm_options; + brdev->stats.tx_packets++; + brdev->stats.tx_bytes += skb->len; + atmvcc->send(atmvcc, skb); + return 1; +} + +static inline struct rt2684_vcc *pick_outgoing_vcc(struct sk_buff *skb, + struct rt2684_dev *brdev) +{ + return list_empty(&brdev->brvccs) ? NULL : + list_entry_brvcc(brdev->brvccs.next); /* 1 vcc/dev right now */ +} + +static int rt2684_start_xmit(struct sk_buff *skb, struct net_device *dev) +{ + struct rt2684_dev *brdev = RTPRIV(dev); + struct rt2684_vcc *brvcc; + + DPRINTK("rt2684_start_xmit, skb->dst=%p\n", skb->dst); + read_lock(&devs_lock); + brvcc = pick_outgoing_vcc(skb, brdev); + if (brvcc == NULL) { + DPRINTK("no vcc attached to dev %s\n", dev->name); + brdev->stats.tx_errors++; + brdev->stats.tx_carrier_errors++; + /* netif_stop_queue(dev); */ + dev_kfree_skb(skb); + read_unlock(&devs_lock); + return -EUNATCH; + } + if (!rt2684_xmit_vcc(skb, brdev, brvcc)) { + /* + * We should probably use netif_*_queue() here, but that + * involves added complication. We need to walk before + * we can run + */ + /* don't free here! this pointer might be no longer valid! + dev_kfree_skb(skb); + */ + brdev->stats.tx_errors++; + brdev->stats.tx_fifo_errors++; + } + read_unlock(&devs_lock); + return 0; +} + +static struct net_device_stats *rt2684_get_stats(struct net_device *dev) +{ + DPRINTK("rt2684_get_stats\n"); + return &RTPRIV(dev)->stats; +} + + +static void rt2684_close_vcc(struct rt2684_vcc *brvcc) +{ + DPRINTK("removing VCC %p from dev %p\n", brvcc, brvcc->device); + write_lock_irq(&devs_lock); + list_del(&brvcc->brvccs); + write_unlock_irq(&devs_lock); + brvcc->atmvcc->user_back = NULL; /* what about vcc->recvq ??? */ + brvcc->old_push(brvcc->atmvcc, NULL); /* pass on the bad news */ + kfree(brvcc); + module_put(THIS_MODULE); +} + +/* when AAL5 PDU comes in: */ +static void rt2684_push(struct atm_vcc *atmvcc, struct sk_buff *skb) +{ + struct rt2684_vcc *brvcc = RT2684_VCC(atmvcc); + struct net_device *net_dev = brvcc->device; + struct rt2684_dev *brdev = RTPRIV(net_dev); + + DPRINTK("rt2684_push\n"); + + if (unlikely(skb == NULL)) { + /* skb==NULL means VCC is being destroyed */ + rt2684_close_vcc(brvcc); + if (list_empty(&brdev->brvccs)) { + read_lock(&devs_lock); + list_del(&brdev->rt2684_devs); + read_unlock(&devs_lock); + unregister_netdev(net_dev); + free_netdev(net_dev); + } + return; + } + + skb_debug(skb); + atm_return(atmvcc, skb->truesize); + DPRINTK("skb from brdev %p\n", brdev); + if (brvcc->encaps == e_llc) { + /* let us waste some time for checking the encapsulation. + Note, that only 7 char is checked so frames with a valid FCS + are also accepted (but FCS is not checked of course) */ + if (memcmp(skb->data, llc_oui, sizeof(llc_oui))) { + brdev->stats.rx_errors++; + dev_kfree_skb(skb); + return; + } + if (skb->len < RFC1483LLC_LEN) { + brdev->stats.rx_errors++; + dev_kfree_skb(skb); /* dev_ not needed? */ + return; + } + skb->protocol = ((u16 *) skb->data)[3]; + skb_pull(skb,RFC1483LLC_LEN); + if (skb->protocol == htons(ETH_P_ARP)) { + //DXXX + printk("arp...\n"); + brdev->stats.rx_errors++; + dev_kfree_skb(skb); + return; + } + + } else { + skb->protocol = htons(ETH_P_IP); + } + +#ifdef DHCP_HACK + //dhcp hack... + if (dhcp_hack && !memcmp(skb->data+16,broadcast, 4) && + htons(*(uint16_t*)(skb->data+20)) == 0x43) { + + printk("dhcp hack rec\n"); + dhcp_hack = 0; + if (skb_headroom(skb) >= 14) { + skb_push( skb, 14 ); + memcpy(skb->data, net_dev->dev_addr, ETH_ALEN); + memcpy(skb->data + 6, net_dev->dev_addr, ETH_ALEN); + skb->data[11] ^=0x1; + skb->data[12] = (uint8_t) 0x08; + skb->data[13] = (uint8_t) 0x00; + } + else + printk("dhcp hack error...\n"); + + } +#endif + + skb->mac.raw = skb->data; + //skb->pkt_type = PACKET_HOST; + skb->dev = net_dev; + ATM_SKB(skb)->vcc = atmvcc; /* needed ? */ + DPRINTK("received packet's protocol: %x\n", ntohs(skb->protocol)); + skb_debug(skb); +#if 1 + if (unlikely(!(net_dev->flags & IFF_UP))) { + /* sigh, interface is down */ + brdev->stats.rx_dropped++; + dev_kfree_skb(skb); + return; + } +#endif + brdev->stats.rx_packets++; + brdev->stats.rx_bytes += skb->len; + memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data)); + netif_rx(skb); +} + +static int rt2684_regvcc(struct atm_vcc *atmvcc, void __user *arg) +{ +/* assign a vcc to a dev +Note: we do not have explicit unassign, but look at _push() +*/ + int err; + struct rt2684_vcc *brvcc; + struct sk_buff_head copy; + struct sk_buff *skb; + struct rt2684_dev *brdev; + struct net_device *net_dev; + struct atm_backend_br2684 be; + + if (copy_from_user(&be, arg, sizeof be)) + return -EFAULT; + brvcc = kmalloc(sizeof(struct rt2684_vcc), GFP_KERNEL); + if (!brvcc) + return -ENOMEM; + memset(brvcc, 0, sizeof(struct rt2684_vcc)); + write_lock_irq(&devs_lock); + net_dev = rt2684_find_dev(&be.ifspec); + if (net_dev == NULL) { + printk(KERN_ERR + "rt2684: tried to attach to non-existant device\n"); + err = -ENXIO; + goto error; + } + brdev = RTPRIV(net_dev); + if (atmvcc->push == NULL) { + err = -EBADFD; + goto error; + } + if (!list_empty(&brdev->brvccs)) { + /* Only 1 VCC/dev right now */ + err = -EEXIST; + goto error; + } + if (be.fcs_in != BR2684_FCSIN_NO || be.fcs_out != BR2684_FCSOUT_NO || + be.fcs_auto || be.has_vpiid || be.send_padding || (be.encaps != + BR2684_ENCAPS_VC && be.encaps != BR2684_ENCAPS_LLC) || + be.min_size != 0) { + err = -EINVAL; + goto error; + } + DPRINTK("rt2684_regvcc vcc=%p, encaps=%d, brvcc=%p\n", atmvcc, be.encaps, + brvcc); + if (list_empty(&brdev->brvccs)) { + unsigned char *esi = atmvcc->dev->esi; + if (esi[0] | esi[1] | esi[2] | esi[3] | esi[4] | esi[5]) + memcpy(net_dev->dev_addr, esi, net_dev->addr_len); + else + net_dev->dev_addr[2] = 1; + } + list_add(&brvcc->brvccs, &brdev->brvccs); + write_unlock_irq(&devs_lock); + brvcc->device = net_dev; + brvcc->atmvcc = atmvcc; + atmvcc->user_back = brvcc; + brvcc->encaps = (enum rt2684_encaps) be.encaps; + brvcc->old_push = atmvcc->push; + barrier(); + atmvcc->push = rt2684_push; + skb_queue_head_init(©); + skb_migrate(&atmvcc->sk->sk_receive_queue, ©); + while ((skb = skb_dequeue(©)) != NULL) { + RTPRIV(skb->dev)->stats.rx_bytes -= skb->len; + RTPRIV(skb->dev)->stats.rx_packets--; + rt2684_push(atmvcc, skb); + } + __module_get(THIS_MODULE); + return 0; + error: + write_unlock_irq(&devs_lock); + kfree(brvcc); + return err; +} + +static void rt2684_setup(struct net_device *dev) +{ + struct rt2684_dev *brdev = RTPRIV(dev); + +#ifdef DHCP_HACK + dev->type = ARPHRD_ETHER; +#else + dev->type = /*ARPHRD_NONE*/ARPHRD_ETHER; +#endif + dev->hard_header_len = RFC1483LLC_LEN; + dev->mtu = RFC1626_MTU; + dev->addr_len = ETH_ALEN; + dev->tx_queue_len = 100; + dev->flags = /*IFF_BROADCAST|*/IFF_NOARP; +// memset(dev->broadcast,0xFF, ETH_ALEN); + + dev->hard_start_xmit = rt2684_start_xmit; + dev->get_stats = rt2684_get_stats; + + brdev->net_dev = dev; + + + INIT_LIST_HEAD(&brdev->brvccs); +} + +static int rt2684_create(void __user *arg) +{ + int err; + struct net_device *netdev; + struct rt2684_dev *brdev; + struct atm_newif_br2684 ni; + + DPRINTK("rt2684_create\n"); + + if (copy_from_user(&ni, arg, sizeof ni)) { + return -EFAULT; + } + //XXX + if (ni.media != BR2684_MEDIA_ETHERNET || ni.mtu != 1500) { + return -EINVAL; + } + + netdev = alloc_netdev(sizeof(struct rt2684_dev), + ni.ifname[0] ? ni.ifname : "nas%d", + rt2684_setup); + if (!netdev) + return -ENOMEM; + + brdev = RTPRIV(netdev); + + DPRINTK("registered netdev %s\n", netdev->name); + /* open, stop, do_ioctl ? */ + err = register_netdev(netdev); + if (err < 0) { + printk(KERN_ERR "rt2684_create: register_netdev failed\n"); + free_netdev(netdev); + return err; + } + + write_lock_irq(&devs_lock); + brdev->number = list_empty(&rt2684_devs) ? 1 : + RTPRIV(list_entry_brdev(rt2684_devs.prev))->number + 1; + list_add_tail(&brdev->rt2684_devs, &rt2684_devs); + write_unlock_irq(&devs_lock); + return 0; +} + +/* + * This handles ioctls actually performed on our vcc - we must return + * -ENOIOCTLCMD for any unrecognized ioctl + */ +static int rt2684_ioctl(struct socket *sock, unsigned int cmd, + unsigned long arg) +{ + struct atm_vcc *atmvcc = ATM_SD(sock); + void __user *argp = (void __user *)arg; + + int err; + switch(cmd) { + case ATM_SETBACKEND: + case ATM_NEWBACKENDIF: { + atm_backend_t b; + err = get_user(b, (atm_backend_t __user *) argp); + if (err) + return -EFAULT; + if (b != ATM_BACKEND_BR2684) + return -ENOIOCTLCMD; + if (!capable(CAP_NET_ADMIN)) + return -EPERM; + if (cmd == ATM_SETBACKEND) + return rt2684_regvcc(atmvcc, argp); + else + return rt2684_create(argp); + } + } + return -ENOIOCTLCMD; +} + +static struct atm_ioctl rt2684_ioctl_ops = { + .owner = THIS_MODULE, + .ioctl = rt2684_ioctl, +}; + + +#ifdef CONFIG_PROC_FS +static void *rt2684_seq_start(struct seq_file *seq, loff_t *pos) +{ + loff_t offs = 0; + struct rt2684_dev *brd; + + read_lock(&devs_lock); + + list_for_each_entry(brd, &rt2684_devs, rt2684_devs) { + if (offs == *pos) + return brd; + ++offs; + } + return NULL; +} + +static void *rt2684_seq_next(struct seq_file *seq, void *v, loff_t *pos) +{ + struct rt2684_dev *brd = v; + + ++*pos; + + brd = list_entry(brd->rt2684_devs.next, + struct rt2684_dev, rt2684_devs); + return (&brd->rt2684_devs != &rt2684_devs) ? brd : NULL; +} + +static void rt2684_seq_stop(struct seq_file *seq, void *v) +{ + read_unlock(&devs_lock); +} + +static int rt2684_seq_show(struct seq_file *seq, void *v) +{ + const struct rt2684_dev *brdev = v; + const struct net_device *net_dev = brdev->net_dev; + const struct rt2684_vcc *brvcc; + + seq_printf(seq, "dev %.16s: num=%d, mac=%02X:%02X:" + "%02X:%02X:%02X:%02X (%s)\n", net_dev->name, + brdev->number, + net_dev->dev_addr[0], + net_dev->dev_addr[1], + net_dev->dev_addr[2], + net_dev->dev_addr[3], + net_dev->dev_addr[4], + net_dev->dev_addr[5], + brdev->mac_was_set ? "set" : "auto"); + + list_for_each_entry(brvcc, &brdev->brvccs, brvccs) { + seq_printf(seq, " vcc %d.%d.%d: encaps=%s" + "\n", brvcc->atmvcc->dev->number, + brvcc->atmvcc->vpi, brvcc->atmvcc->vci, + (brvcc->encaps == e_llc) ? "LLC" : "VC" + ); + } + return 0; +} + +static struct seq_operations rt2684_seq_ops = { + .start = rt2684_seq_start, + .next = rt2684_seq_next, + .stop = rt2684_seq_stop, + .show = rt2684_seq_show, +}; + +static int rt2684_proc_open(struct inode *inode, struct file *file) +{ + return seq_open(file, &rt2684_seq_ops); +} + +static struct file_operations rt2684_proc_ops = { + .owner = THIS_MODULE, + .open = rt2684_proc_open, + .read = seq_read, + .llseek = seq_lseek, + .release = seq_release, +}; + +extern struct proc_dir_entry *atm_proc_root; /* from proc.c */ +#endif + +static int __init rt2684_init(void) +{ +#ifdef CONFIG_PROC_FS + struct proc_dir_entry *p; + if ((p = create_proc_entry("rt2684", 0, atm_proc_root)) == NULL) + return -ENOMEM; + p->proc_fops = &rt2684_proc_ops; +#endif + register_atm_ioctl(&rt2684_ioctl_ops); + return 0; +} + +static void __exit rt2684_exit(void) +{ + struct net_device *net_dev; + struct rt2684_dev *brdev; + struct rt2684_vcc *brvcc; + deregister_atm_ioctl(&rt2684_ioctl_ops); + +#ifdef CONFIG_PROC_FS + remove_proc_entry("rt2684", atm_proc_root); +#endif + + while (!list_empty(&rt2684_devs)) { + net_dev = list_entry_brdev(rt2684_devs.next); + brdev = RTPRIV(net_dev); + while (!list_empty(&brdev->brvccs)) { + brvcc = list_entry_brvcc(brdev->brvccs.next); + rt2684_close_vcc(brvcc); + } + + list_del(&brdev->rt2684_devs); + unregister_netdev(net_dev); + free_netdev(net_dev); + } +} + +module_init(rt2684_init); +module_exit(rt2684_exit); + +MODULE_AUTHOR("Marcell GAL, Matthieu CASTET"); +MODULE_DESCRIPTION("RFC2684 routed protocols over ATM/AAL5"); +MODULE_LICENSE("GPL"); --- linux-2.6.9/net/Kconfig 2004-10-18 23:53:10.000000000 +0200 +++ linux-2.6.10/net/Kconfig 2005-01-04 19:52:36.000000000 +0100 @@ -294,6 +298,15 @@ large number of IP-only vcc's. Do not enable this unless you are sure you know what you are doing. +config ATM_RT2684 + tristate "RFC2684 Routed protocols" + depends on ATM && INET + help + config BRIDGE tristate "802.1d Ethernet Bridging" ---help---