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