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