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