linux/net/atm/br2684.c
<<
>>
Prefs
   1/*
   2 * Ethernet netdevice using ATM AAL5 as underlying carrier
   3 * (RFC1483 obsoleted by RFC2684) for Linux
   4 *
   5 * Authors: Marcell GAL, 2000, XDSL Ltd, Hungary
   6 *          Eric Kinzie, 2006-2007, US Naval Research Laboratory
   7 */
   8
   9#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__
  10
  11#include <linux/module.h>
  12#include <linux/init.h>
  13#include <linux/kernel.h>
  14#include <linux/list.h>
  15#include <linux/netdevice.h>
  16#include <linux/skbuff.h>
  17#include <linux/etherdevice.h>
  18#include <linux/rtnetlink.h>
  19#include <linux/ip.h>
  20#include <linux/uaccess.h>
  21#include <linux/slab.h>
  22#include <net/arp.h>
  23#include <linux/atm.h>
  24#include <linux/atmdev.h>
  25#include <linux/capability.h>
  26#include <linux/seq_file.h>
  27
  28#include <linux/atmbr2684.h>
  29
  30#include "common.h"
  31
  32static void skb_debug(const struct sk_buff *skb)
  33{
  34#ifdef SKB_DEBUG
  35#define NUM2PRINT 50
  36        print_hex_dump(KERN_DEBUG, "br2684: skb: ", DUMP_OFFSET,
  37                       16, 1, skb->data, min(NUM2PRINT, skb->len), true);
  38#endif
  39}
  40
  41#define BR2684_ETHERTYPE_LEN    2
  42#define BR2684_PAD_LEN          2
  43
  44#define LLC             0xaa, 0xaa, 0x03
  45#define SNAP_BRIDGED    0x00, 0x80, 0xc2
  46#define SNAP_ROUTED     0x00, 0x00, 0x00
  47#define PID_ETHERNET    0x00, 0x07
  48#define ETHERTYPE_IPV4  0x08, 0x00
  49#define ETHERTYPE_IPV6  0x86, 0xdd
  50#define PAD_BRIDGED     0x00, 0x00
  51
  52static const unsigned char ethertype_ipv4[] = { ETHERTYPE_IPV4 };
  53static const unsigned char ethertype_ipv6[] = { ETHERTYPE_IPV6 };
  54static const unsigned char llc_oui_pid_pad[] =
  55                        { LLC, SNAP_BRIDGED, PID_ETHERNET, PAD_BRIDGED };
  56static const unsigned char pad[] = { PAD_BRIDGED };
  57static const unsigned char llc_oui_ipv4[] = { LLC, SNAP_ROUTED, ETHERTYPE_IPV4 };
  58static const unsigned char llc_oui_ipv6[] = { LLC, SNAP_ROUTED, ETHERTYPE_IPV6 };
  59
  60enum br2684_encaps {
  61        e_vc = BR2684_ENCAPS_VC,
  62        e_llc = BR2684_ENCAPS_LLC,
  63};
  64
  65struct br2684_vcc {
  66        struct atm_vcc *atmvcc;
  67        struct net_device *device;
  68        /* keep old push, pop functions for chaining */
  69        void (*old_push)(struct atm_vcc *vcc, struct sk_buff *skb);
  70        void (*old_pop)(struct atm_vcc *vcc, struct sk_buff *skb);
  71        enum br2684_encaps encaps;
  72        struct list_head brvccs;
  73#ifdef CONFIG_ATM_BR2684_IPFILTER
  74        struct br2684_filter filter;
  75#endif /* CONFIG_ATM_BR2684_IPFILTER */
  76        unsigned int copies_needed, copies_failed;
  77};
  78
  79struct br2684_dev {
  80        struct net_device *net_dev;
  81        struct list_head br2684_devs;
  82        int number;
  83        struct list_head brvccs;        /* one device <=> one vcc (before xmas) */
  84        int mac_was_set;
  85        enum br2684_payload payload;
  86};
  87
  88/*
  89 * This lock should be held for writing any time the list of devices or
  90 * their attached vcc's could be altered.  It should be held for reading
  91 * any time these are being queried.  Note that we sometimes need to
  92 * do read-locking under interrupt context, so write locking must block
  93 * the current CPU's interrupts
  94 */
  95static DEFINE_RWLOCK(devs_lock);
  96
  97static LIST_HEAD(br2684_devs);
  98
  99static inline struct br2684_dev *BRPRIV(const struct net_device *net_dev)
 100{
 101        return netdev_priv(net_dev);
 102}
 103
 104static inline struct net_device *list_entry_brdev(const struct list_head *le)
 105{
 106        return list_entry(le, struct br2684_dev, br2684_devs)->net_dev;
 107}
 108
 109static inline struct br2684_vcc *BR2684_VCC(const struct atm_vcc *atmvcc)
 110{
 111        return (struct br2684_vcc *)(atmvcc->user_back);
 112}
 113
 114static inline struct br2684_vcc *list_entry_brvcc(const struct list_head *le)
 115{
 116        return list_entry(le, struct br2684_vcc, brvccs);
 117}
 118
 119/* Caller should hold read_lock(&devs_lock) */
 120static struct net_device *br2684_find_dev(const struct br2684_if_spec *s)
 121{
 122        struct list_head *lh;
 123        struct net_device *net_dev;
 124        switch (s->method) {
 125        case BR2684_FIND_BYNUM:
 126                list_for_each(lh, &br2684_devs) {
 127                        net_dev = list_entry_brdev(lh);
 128                        if (BRPRIV(net_dev)->number == s->spec.devnum)
 129                                return net_dev;
 130                }
 131                break;
 132        case BR2684_FIND_BYIFNAME:
 133                list_for_each(lh, &br2684_devs) {
 134                        net_dev = list_entry_brdev(lh);
 135                        if (!strncmp(net_dev->name, s->spec.ifname, IFNAMSIZ))
 136                                return net_dev;
 137                }
 138                break;
 139        }
 140        return NULL;
 141}
 142
 143static int atm_dev_event(struct notifier_block *this, unsigned long event,
 144                 void *arg)
 145{
 146        struct atm_dev *atm_dev = arg;
 147        struct list_head *lh;
 148        struct net_device *net_dev;
 149        struct br2684_vcc *brvcc;
 150        struct atm_vcc *atm_vcc;
 151        unsigned long flags;
 152
 153        pr_debug("event=%ld dev=%p\n", event, atm_dev);
 154
 155        read_lock_irqsave(&devs_lock, flags);
 156        list_for_each(lh, &br2684_devs) {
 157                net_dev = list_entry_brdev(lh);
 158
 159                list_for_each_entry(brvcc, &BRPRIV(net_dev)->brvccs, brvccs) {
 160                        atm_vcc = brvcc->atmvcc;
 161                        if (atm_vcc && brvcc->atmvcc->dev == atm_dev) {
 162
 163                                if (atm_vcc->dev->signal == ATM_PHY_SIG_LOST)
 164                                        netif_carrier_off(net_dev);
 165                                else
 166                                        netif_carrier_on(net_dev);
 167
 168                        }
 169                }
 170        }
 171        read_unlock_irqrestore(&devs_lock, flags);
 172
 173        return NOTIFY_DONE;
 174}
 175
 176static struct notifier_block atm_dev_notifier = {
 177        .notifier_call = atm_dev_event,
 178};
 179
 180/* chained vcc->pop function.  Check if we should wake the netif_queue */
 181static void br2684_pop(struct atm_vcc *vcc, struct sk_buff *skb)
 182{
 183        struct br2684_vcc *brvcc = BR2684_VCC(vcc);
 184        struct net_device *net_dev = skb->dev;
 185
 186        pr_debug("(vcc %p ; net_dev %p )\n", vcc, net_dev);
 187        brvcc->old_pop(vcc, skb);
 188
 189        if (!net_dev)
 190                return;
 191
 192        if (atm_may_send(vcc, 0))
 193                netif_wake_queue(net_dev);
 194
 195}
 196/*
 197 * Send a packet out a particular vcc.  Not to useful right now, but paves
 198 * the way for multiple vcc's per itf.  Returns true if we can send,
 199 * otherwise false
 200 */
 201static int br2684_xmit_vcc(struct sk_buff *skb, struct net_device *dev,
 202                           struct br2684_vcc *brvcc)
 203{
 204        struct br2684_dev *brdev = BRPRIV(dev);
 205        struct atm_vcc *atmvcc;
 206        int minheadroom = (brvcc->encaps == e_llc) ?
 207                ((brdev->payload == p_bridged) ?
 208                        sizeof(llc_oui_pid_pad) : sizeof(llc_oui_ipv4)) :
 209                ((brdev->payload == p_bridged) ? BR2684_PAD_LEN : 0);
 210
 211        if (skb_headroom(skb) < minheadroom) {
 212                struct sk_buff *skb2 = skb_realloc_headroom(skb, minheadroom);
 213                brvcc->copies_needed++;
 214                dev_kfree_skb(skb);
 215                if (skb2 == NULL) {
 216                        brvcc->copies_failed++;
 217                        return 0;
 218                }
 219                skb = skb2;
 220        }
 221
 222        if (brvcc->encaps == e_llc) {
 223                if (brdev->payload == p_bridged) {
 224                        skb_push(skb, sizeof(llc_oui_pid_pad));
 225                        skb_copy_to_linear_data(skb, llc_oui_pid_pad,
 226                                                sizeof(llc_oui_pid_pad));
 227                } else if (brdev->payload == p_routed) {
 228                        unsigned short prot = ntohs(skb->protocol);
 229
 230                        skb_push(skb, sizeof(llc_oui_ipv4));
 231                        switch (prot) {
 232                        case ETH_P_IP:
 233                                skb_copy_to_linear_data(skb, llc_oui_ipv4,
 234                                                        sizeof(llc_oui_ipv4));
 235                                break;
 236                        case ETH_P_IPV6:
 237                                skb_copy_to_linear_data(skb, llc_oui_ipv6,
 238                                                        sizeof(llc_oui_ipv6));
 239                                break;
 240                        default:
 241                                dev_kfree_skb(skb);
 242                                return 0;
 243                        }
 244                }
 245        } else { /* e_vc */
 246                if (brdev->payload == p_bridged) {
 247                        skb_push(skb, 2);
 248                        memset(skb->data, 0, 2);
 249                }
 250        }
 251        skb_debug(skb);
 252
 253        ATM_SKB(skb)->vcc = atmvcc = brvcc->atmvcc;
 254        pr_debug("atm_skb(%p)->vcc(%p)->dev(%p)\n", skb, atmvcc, atmvcc->dev);
 255        atomic_add(skb->truesize, &sk_atm(atmvcc)->sk_wmem_alloc);
 256        ATM_SKB(skb)->atm_options = atmvcc->atm_options;
 257        dev->stats.tx_packets++;
 258        dev->stats.tx_bytes += skb->len;
 259        atmvcc->send(atmvcc, skb);
 260
 261        if (!atm_may_send(atmvcc, 0)) {
 262                netif_stop_queue(brvcc->device);
 263                /*check for race with br2684_pop*/
 264                if (atm_may_send(atmvcc, 0))
 265                        netif_start_queue(brvcc->device);
 266        }
 267
 268        return 1;
 269}
 270
 271static inline struct br2684_vcc *pick_outgoing_vcc(const struct sk_buff *skb,
 272                                                   const struct br2684_dev *brdev)
 273{
 274        return list_empty(&brdev->brvccs) ? NULL : list_entry_brvcc(brdev->brvccs.next);        /* 1 vcc/dev right now */
 275}
 276
 277static netdev_tx_t br2684_start_xmit(struct sk_buff *skb,
 278                                     struct net_device *dev)
 279{
 280        struct br2684_dev *brdev = BRPRIV(dev);
 281        struct br2684_vcc *brvcc;
 282
 283        pr_debug("skb_dst(skb)=%p\n", skb_dst(skb));
 284        read_lock(&devs_lock);
 285        brvcc = pick_outgoing_vcc(skb, brdev);
 286        if (brvcc == NULL) {
 287                pr_debug("no vcc attached to dev %s\n", dev->name);
 288                dev->stats.tx_errors++;
 289                dev->stats.tx_carrier_errors++;
 290                /* netif_stop_queue(dev); */
 291                dev_kfree_skb(skb);
 292                read_unlock(&devs_lock);
 293                return NETDEV_TX_OK;
 294        }
 295        if (!br2684_xmit_vcc(skb, dev, brvcc)) {
 296                /*
 297                 * We should probably use netif_*_queue() here, but that
 298                 * involves added complication.  We need to walk before
 299                 * we can run.
 300                 *
 301                 * Don't free here! this pointer might be no longer valid!
 302                 */
 303                dev->stats.tx_errors++;
 304                dev->stats.tx_fifo_errors++;
 305        }
 306        read_unlock(&devs_lock);
 307        return NETDEV_TX_OK;
 308}
 309
 310/*
 311 * We remember when the MAC gets set, so we don't override it later with
 312 * the ESI of the ATM card of the first VC
 313 */
 314static int br2684_mac_addr(struct net_device *dev, void *p)
 315{
 316        int err = eth_mac_addr(dev, p);
 317        if (!err)
 318                BRPRIV(dev)->mac_was_set = 1;
 319        return err;
 320}
 321
 322#ifdef CONFIG_ATM_BR2684_IPFILTER
 323/* this IOCTL is experimental. */
 324static int br2684_setfilt(struct atm_vcc *atmvcc, void __user * arg)
 325{
 326        struct br2684_vcc *brvcc;
 327        struct br2684_filter_set fs;
 328
 329        if (copy_from_user(&fs, arg, sizeof fs))
 330                return -EFAULT;
 331        if (fs.ifspec.method != BR2684_FIND_BYNOTHING) {
 332                /*
 333                 * This is really a per-vcc thing, but we can also search
 334                 * by device.
 335                 */
 336                struct br2684_dev *brdev;
 337                read_lock(&devs_lock);
 338                brdev = BRPRIV(br2684_find_dev(&fs.ifspec));
 339                if (brdev == NULL || list_empty(&brdev->brvccs) ||
 340                    brdev->brvccs.next != brdev->brvccs.prev)   /* >1 VCC */
 341                        brvcc = NULL;
 342                else
 343                        brvcc = list_entry_brvcc(brdev->brvccs.next);
 344                read_unlock(&devs_lock);
 345                if (brvcc == NULL)
 346                        return -ESRCH;
 347        } else
 348                brvcc = BR2684_VCC(atmvcc);
 349        memcpy(&brvcc->filter, &fs.filter, sizeof(brvcc->filter));
 350        return 0;
 351}
 352
 353/* Returns 1 if packet should be dropped */
 354static inline int
 355packet_fails_filter(__be16 type, struct br2684_vcc *brvcc, struct sk_buff *skb)
 356{
 357        if (brvcc->filter.netmask == 0)
 358                return 0;       /* no filter in place */
 359        if (type == htons(ETH_P_IP) &&
 360            (((struct iphdr *)(skb->data))->daddr & brvcc->filter.
 361             netmask) == brvcc->filter.prefix)
 362                return 0;
 363        if (type == htons(ETH_P_ARP))
 364                return 0;
 365        /*
 366         * TODO: we should probably filter ARPs too.. don't want to have
 367         * them returning values that don't make sense, or is that ok?
 368         */
 369        return 1;               /* drop */
 370}
 371#endif /* CONFIG_ATM_BR2684_IPFILTER */
 372
 373static void br2684_close_vcc(struct br2684_vcc *brvcc)
 374{
 375        pr_debug("removing VCC %p from dev %p\n", brvcc, brvcc->device);
 376        write_lock_irq(&devs_lock);
 377        list_del(&brvcc->brvccs);
 378        write_unlock_irq(&devs_lock);
 379        brvcc->atmvcc->user_back = NULL;        /* what about vcc->recvq ??? */
 380        brvcc->old_push(brvcc->atmvcc, NULL);   /* pass on the bad news */
 381        kfree(brvcc);
 382        module_put(THIS_MODULE);
 383}
 384
 385/* when AAL5 PDU comes in: */
 386static void br2684_push(struct atm_vcc *atmvcc, struct sk_buff *skb)
 387{
 388        struct br2684_vcc *brvcc = BR2684_VCC(atmvcc);
 389        struct net_device *net_dev = brvcc->device;
 390        struct br2684_dev *brdev = BRPRIV(net_dev);
 391
 392        pr_debug("\n");
 393
 394        if (unlikely(skb == NULL)) {
 395                /* skb==NULL means VCC is being destroyed */
 396                br2684_close_vcc(brvcc);
 397                if (list_empty(&brdev->brvccs)) {
 398                        write_lock_irq(&devs_lock);
 399                        list_del(&brdev->br2684_devs);
 400                        write_unlock_irq(&devs_lock);
 401                        unregister_netdev(net_dev);
 402                        free_netdev(net_dev);
 403                }
 404                return;
 405        }
 406
 407        skb_debug(skb);
 408        atm_return(atmvcc, skb->truesize);
 409        pr_debug("skb from brdev %p\n", brdev);
 410        if (brvcc->encaps == e_llc) {
 411
 412                if (skb->len > 7 && skb->data[7] == 0x01)
 413                        __skb_trim(skb, skb->len - 4);
 414
 415                /* accept packets that have "ipv[46]" in the snap header */
 416                if ((skb->len >= (sizeof(llc_oui_ipv4))) &&
 417                    (memcmp(skb->data, llc_oui_ipv4,
 418                            sizeof(llc_oui_ipv4) - BR2684_ETHERTYPE_LEN) == 0)) {
 419                        if (memcmp(skb->data + 6, ethertype_ipv6,
 420                                   sizeof(ethertype_ipv6)) == 0)
 421                                skb->protocol = htons(ETH_P_IPV6);
 422                        else if (memcmp(skb->data + 6, ethertype_ipv4,
 423                                        sizeof(ethertype_ipv4)) == 0)
 424                                skb->protocol = htons(ETH_P_IP);
 425                        else
 426                                goto error;
 427                        skb_pull(skb, sizeof(llc_oui_ipv4));
 428                        skb_reset_network_header(skb);
 429                        skb->pkt_type = PACKET_HOST;
 430                /*
 431                 * Let us waste some time for checking the encapsulation.
 432                 * Note, that only 7 char is checked so frames with a valid FCS
 433                 * are also accepted (but FCS is not checked of course).
 434                 */
 435                } else if ((skb->len >= sizeof(llc_oui_pid_pad)) &&
 436                           (memcmp(skb->data, llc_oui_pid_pad, 7) == 0)) {
 437                        skb_pull(skb, sizeof(llc_oui_pid_pad));
 438                        skb->protocol = eth_type_trans(skb, net_dev);
 439                } else
 440                        goto error;
 441
 442        } else { /* e_vc */
 443                if (brdev->payload == p_routed) {
 444                        struct iphdr *iph;
 445
 446                        skb_reset_network_header(skb);
 447                        iph = ip_hdr(skb);
 448                        if (iph->version == 4)
 449                                skb->protocol = htons(ETH_P_IP);
 450                        else if (iph->version == 6)
 451                                skb->protocol = htons(ETH_P_IPV6);
 452                        else
 453                                goto error;
 454                        skb->pkt_type = PACKET_HOST;
 455                } else { /* p_bridged */
 456                        /* first 2 chars should be 0 */
 457                        if (memcmp(skb->data, pad, BR2684_PAD_LEN) != 0)
 458                                goto error;
 459                        skb_pull(skb, BR2684_PAD_LEN);
 460                        skb->protocol = eth_type_trans(skb, net_dev);
 461                }
 462        }
 463
 464#ifdef CONFIG_ATM_BR2684_IPFILTER
 465        if (unlikely(packet_fails_filter(skb->protocol, brvcc, skb)))
 466                goto dropped;
 467#endif /* CONFIG_ATM_BR2684_IPFILTER */
 468        skb->dev = net_dev;
 469        ATM_SKB(skb)->vcc = atmvcc;     /* needed ? */
 470        pr_debug("received packet's protocol: %x\n", ntohs(skb->protocol));
 471        skb_debug(skb);
 472        /* sigh, interface is down? */
 473        if (unlikely(!(net_dev->flags & IFF_UP)))
 474                goto dropped;
 475        net_dev->stats.rx_packets++;
 476        net_dev->stats.rx_bytes += skb->len;
 477        memset(ATM_SKB(skb), 0, sizeof(struct atm_skb_data));
 478        netif_rx(skb);
 479        return;
 480
 481dropped:
 482        net_dev->stats.rx_dropped++;
 483        goto free_skb;
 484error:
 485        net_dev->stats.rx_errors++;
 486free_skb:
 487        dev_kfree_skb(skb);
 488}
 489
 490/*
 491 * Assign a vcc to a dev
 492 * Note: we do not have explicit unassign, but look at _push()
 493 */
 494static int br2684_regvcc(struct atm_vcc *atmvcc, void __user * arg)
 495{
 496        struct br2684_vcc *brvcc;
 497        struct br2684_dev *brdev;
 498        struct net_device *net_dev;
 499        struct atm_backend_br2684 be;
 500        int err;
 501
 502        if (copy_from_user(&be, arg, sizeof be))
 503                return -EFAULT;
 504        brvcc = kzalloc(sizeof(struct br2684_vcc), GFP_KERNEL);
 505        if (!brvcc)
 506                return -ENOMEM;
 507        write_lock_irq(&devs_lock);
 508        net_dev = br2684_find_dev(&be.ifspec);
 509        if (net_dev == NULL) {
 510                pr_err("tried to attach to non-existent device\n");
 511                err = -ENXIO;
 512                goto error;
 513        }
 514        brdev = BRPRIV(net_dev);
 515        if (atmvcc->push == NULL) {
 516                err = -EBADFD;
 517                goto error;
 518        }
 519        if (!list_empty(&brdev->brvccs)) {
 520                /* Only 1 VCC/dev right now */
 521                err = -EEXIST;
 522                goto error;
 523        }
 524        if (be.fcs_in != BR2684_FCSIN_NO ||
 525            be.fcs_out != BR2684_FCSOUT_NO ||
 526            be.fcs_auto || be.has_vpiid || be.send_padding ||
 527            (be.encaps != BR2684_ENCAPS_VC &&
 528             be.encaps != BR2684_ENCAPS_LLC) ||
 529            be.min_size != 0) {
 530                err = -EINVAL;
 531                goto error;
 532        }
 533        pr_debug("vcc=%p, encaps=%d, brvcc=%p\n", atmvcc, be.encaps, brvcc);
 534        if (list_empty(&brdev->brvccs) && !brdev->mac_was_set) {
 535                unsigned char *esi = atmvcc->dev->esi;
 536                if (esi[0] | esi[1] | esi[2] | esi[3] | esi[4] | esi[5])
 537                        memcpy(net_dev->dev_addr, esi, net_dev->addr_len);
 538                else
 539                        net_dev->dev_addr[2] = 1;
 540        }
 541        list_add(&brvcc->brvccs, &brdev->brvccs);
 542        write_unlock_irq(&devs_lock);
 543        brvcc->device = net_dev;
 544        brvcc->atmvcc = atmvcc;
 545        atmvcc->user_back = brvcc;
 546        brvcc->encaps = (enum br2684_encaps)be.encaps;
 547        brvcc->old_push = atmvcc->push;
 548        brvcc->old_pop = atmvcc->pop;
 549        barrier();
 550        atmvcc->push = br2684_push;
 551        atmvcc->pop = br2684_pop;
 552
 553        /* initialize netdev carrier state */
 554        if (atmvcc->dev->signal == ATM_PHY_SIG_LOST)
 555                netif_carrier_off(net_dev);
 556        else
 557                netif_carrier_on(net_dev);
 558
 559        __module_get(THIS_MODULE);
 560
 561        /* re-process everything received between connection setup and
 562           backend setup */
 563        vcc_process_recv_queue(atmvcc);
 564        return 0;
 565
 566error:
 567        write_unlock_irq(&devs_lock);
 568        kfree(brvcc);
 569        return err;
 570}
 571
 572static const struct net_device_ops br2684_netdev_ops = {
 573        .ndo_start_xmit         = br2684_start_xmit,
 574        .ndo_set_mac_address    = br2684_mac_addr,
 575        .ndo_change_mtu         = eth_change_mtu,
 576        .ndo_validate_addr      = eth_validate_addr,
 577};
 578
 579static const struct net_device_ops br2684_netdev_ops_routed = {
 580        .ndo_start_xmit         = br2684_start_xmit,
 581        .ndo_set_mac_address    = br2684_mac_addr,
 582        .ndo_change_mtu         = eth_change_mtu
 583};
 584
 585static void br2684_setup(struct net_device *netdev)
 586{
 587        struct br2684_dev *brdev = BRPRIV(netdev);
 588
 589        ether_setup(netdev);
 590        netdev->hard_header_len += sizeof(llc_oui_pid_pad); /* worst case */
 591        brdev->net_dev = netdev;
 592
 593        netdev->netdev_ops = &br2684_netdev_ops;
 594
 595        INIT_LIST_HEAD(&brdev->brvccs);
 596}
 597
 598static void br2684_setup_routed(struct net_device *netdev)
 599{
 600        struct br2684_dev *brdev = BRPRIV(netdev);
 601
 602        brdev->net_dev = netdev;
 603        netdev->hard_header_len = sizeof(llc_oui_ipv4); /* worst case */
 604        netdev->netdev_ops = &br2684_netdev_ops_routed;
 605        netdev->addr_len = 0;
 606        netdev->mtu = 1500;
 607        netdev->type = ARPHRD_PPP;
 608        netdev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
 609        netdev->tx_queue_len = 100;
 610        INIT_LIST_HEAD(&brdev->brvccs);
 611}
 612
 613static int br2684_create(void __user *arg)
 614{
 615        int err;
 616        struct net_device *netdev;
 617        struct br2684_dev *brdev;
 618        struct atm_newif_br2684 ni;
 619        enum br2684_payload payload;
 620
 621        pr_debug("\n");
 622
 623        if (copy_from_user(&ni, arg, sizeof ni))
 624                return -EFAULT;
 625
 626        if (ni.media & BR2684_FLAG_ROUTED)
 627                payload = p_routed;
 628        else
 629                payload = p_bridged;
 630        ni.media &= 0xffff;     /* strip flags */
 631
 632        if (ni.media != BR2684_MEDIA_ETHERNET || ni.mtu != 1500)
 633                return -EINVAL;
 634
 635        netdev = alloc_netdev(sizeof(struct br2684_dev),
 636                              ni.ifname[0] ? ni.ifname : "nas%d",
 637                              (payload == p_routed) ?
 638                              br2684_setup_routed : br2684_setup);
 639        if (!netdev)
 640                return -ENOMEM;
 641
 642        brdev = BRPRIV(netdev);
 643
 644        pr_debug("registered netdev %s\n", netdev->name);
 645        /* open, stop, do_ioctl ? */
 646        err = register_netdev(netdev);
 647        if (err < 0) {
 648                pr_err("register_netdev failed\n");
 649                free_netdev(netdev);
 650                return err;
 651        }
 652
 653        write_lock_irq(&devs_lock);
 654
 655        brdev->payload = payload;
 656
 657        if (list_empty(&br2684_devs)) {
 658                /* 1st br2684 device */
 659                brdev->number = 1;
 660        } else
 661                brdev->number = BRPRIV(list_entry_brdev(br2684_devs.prev))->number + 1;
 662
 663        list_add_tail(&brdev->br2684_devs, &br2684_devs);
 664        write_unlock_irq(&devs_lock);
 665        return 0;
 666}
 667
 668/*
 669 * This handles ioctls actually performed on our vcc - we must return
 670 * -ENOIOCTLCMD for any unrecognized ioctl
 671 */
 672static int br2684_ioctl(struct socket *sock, unsigned int cmd,
 673                        unsigned long arg)
 674{
 675        struct atm_vcc *atmvcc = ATM_SD(sock);
 676        void __user *argp = (void __user *)arg;
 677        atm_backend_t b;
 678
 679        int err;
 680        switch (cmd) {
 681        case ATM_SETBACKEND:
 682        case ATM_NEWBACKENDIF:
 683                err = get_user(b, (atm_backend_t __user *) argp);
 684                if (err)
 685                        return -EFAULT;
 686                if (b != ATM_BACKEND_BR2684)
 687                        return -ENOIOCTLCMD;
 688                if (!capable(CAP_NET_ADMIN))
 689                        return -EPERM;
 690                if (cmd == ATM_SETBACKEND)
 691                        return br2684_regvcc(atmvcc, argp);
 692                else
 693                        return br2684_create(argp);
 694#ifdef CONFIG_ATM_BR2684_IPFILTER
 695        case BR2684_SETFILT:
 696                if (atmvcc->push != br2684_push)
 697                        return -ENOIOCTLCMD;
 698                if (!capable(CAP_NET_ADMIN))
 699                        return -EPERM;
 700                err = br2684_setfilt(atmvcc, argp);
 701
 702                return err;
 703#endif /* CONFIG_ATM_BR2684_IPFILTER */
 704        }
 705        return -ENOIOCTLCMD;
 706}
 707
 708static struct atm_ioctl br2684_ioctl_ops = {
 709        .owner = THIS_MODULE,
 710        .ioctl = br2684_ioctl,
 711};
 712
 713#ifdef CONFIG_PROC_FS
 714static void *br2684_seq_start(struct seq_file *seq, loff_t * pos)
 715        __acquires(devs_lock)
 716{
 717        read_lock(&devs_lock);
 718        return seq_list_start(&br2684_devs, *pos);
 719}
 720
 721static void *br2684_seq_next(struct seq_file *seq, void *v, loff_t * pos)
 722{
 723        return seq_list_next(v, &br2684_devs, pos);
 724}
 725
 726static void br2684_seq_stop(struct seq_file *seq, void *v)
 727        __releases(devs_lock)
 728{
 729        read_unlock(&devs_lock);
 730}
 731
 732static int br2684_seq_show(struct seq_file *seq, void *v)
 733{
 734        const struct br2684_dev *brdev = list_entry(v, struct br2684_dev,
 735                                                    br2684_devs);
 736        const struct net_device *net_dev = brdev->net_dev;
 737        const struct br2684_vcc *brvcc;
 738
 739        seq_printf(seq, "dev %.16s: num=%d, mac=%pM (%s)\n",
 740                   net_dev->name,
 741                   brdev->number,
 742                   net_dev->dev_addr,
 743                   brdev->mac_was_set ? "set" : "auto");
 744
 745        list_for_each_entry(brvcc, &brdev->brvccs, brvccs) {
 746                seq_printf(seq, "  vcc %d.%d.%d: encaps=%s payload=%s"
 747                           ", failed copies %u/%u"
 748                           "\n", brvcc->atmvcc->dev->number,
 749                           brvcc->atmvcc->vpi, brvcc->atmvcc->vci,
 750                           (brvcc->encaps == e_llc) ? "LLC" : "VC",
 751                           (brdev->payload == p_bridged) ? "bridged" : "routed",
 752                           brvcc->copies_failed, brvcc->copies_needed);
 753#ifdef CONFIG_ATM_BR2684_IPFILTER
 754#define b1(var, byte)   ((u8 *) &brvcc->filter.var)[byte]
 755#define bs(var)         b1(var, 0), b1(var, 1), b1(var, 2), b1(var, 3)
 756                if (brvcc->filter.netmask != 0)
 757                        seq_printf(seq, "    filter=%d.%d.%d.%d/"
 758                                   "%d.%d.%d.%d\n", bs(prefix), bs(netmask));
 759#undef bs
 760#undef b1
 761#endif /* CONFIG_ATM_BR2684_IPFILTER */
 762        }
 763        return 0;
 764}
 765
 766static const struct seq_operations br2684_seq_ops = {
 767        .start = br2684_seq_start,
 768        .next = br2684_seq_next,
 769        .stop = br2684_seq_stop,
 770        .show = br2684_seq_show,
 771};
 772
 773static int br2684_proc_open(struct inode *inode, struct file *file)
 774{
 775        return seq_open(file, &br2684_seq_ops);
 776}
 777
 778static const struct file_operations br2684_proc_ops = {
 779        .owner = THIS_MODULE,
 780        .open = br2684_proc_open,
 781        .read = seq_read,
 782        .llseek = seq_lseek,
 783        .release = seq_release,
 784};
 785
 786extern struct proc_dir_entry *atm_proc_root;    /* from proc.c */
 787#endif /* CONFIG_PROC_FS */
 788
 789static int __init br2684_init(void)
 790{
 791#ifdef CONFIG_PROC_FS
 792        struct proc_dir_entry *p;
 793        p = proc_create("br2684", 0, atm_proc_root, &br2684_proc_ops);
 794        if (p == NULL)
 795                return -ENOMEM;
 796#endif
 797        register_atm_ioctl(&br2684_ioctl_ops);
 798        register_atmdevice_notifier(&atm_dev_notifier);
 799        return 0;
 800}
 801
 802static void __exit br2684_exit(void)
 803{
 804        struct net_device *net_dev;
 805        struct br2684_dev *brdev;
 806        struct br2684_vcc *brvcc;
 807        deregister_atm_ioctl(&br2684_ioctl_ops);
 808
 809#ifdef CONFIG_PROC_FS
 810        remove_proc_entry("br2684", atm_proc_root);
 811#endif
 812
 813
 814        unregister_atmdevice_notifier(&atm_dev_notifier);
 815
 816        while (!list_empty(&br2684_devs)) {
 817                net_dev = list_entry_brdev(br2684_devs.next);
 818                brdev = BRPRIV(net_dev);
 819                while (!list_empty(&brdev->brvccs)) {
 820                        brvcc = list_entry_brvcc(brdev->brvccs.next);
 821                        br2684_close_vcc(brvcc);
 822                }
 823
 824                list_del(&brdev->br2684_devs);
 825                unregister_netdev(net_dev);
 826                free_netdev(net_dev);
 827        }
 828}
 829
 830module_init(br2684_init);
 831module_exit(br2684_exit);
 832
 833MODULE_AUTHOR("Marcell GAL");
 834MODULE_DESCRIPTION("RFC2684 bridged protocols over ATM/AAL5");
 835MODULE_LICENSE("GPL");
 836
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.