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