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