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