1/* 2 * TUN - Universal TUN/TAP device driver. 3 * Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com> 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 * 15 * $Id: tun.c,v 1.15 2002/03/01 02:44:24 Exp $ 16 */ 17 18/* 19 * Changes: 20 * 21 * Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14 22 * Add TUNSETLINK ioctl to set the link encapsulation 23 * 24 * Mark Smith <markzzzsmith@yahoo.com.au> 25 * Use random_ether_addr() for tap MAC address. 26 * 27 * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20 28 * Fixes in packet dropping, queue length setting and queue wakeup. 29 * Increased default tx queue length. 30 * Added ethtool API. 31 * Minor cleanups 32 * 33 * Daniel Podlejski <underley@underley.eu.org> 34 * Modifications for 2.3.99-pre5 kernel. 35 */ 36 37#define DRV_NAME "tun" 38#define DRV_VERSION "1.6" 39#define DRV_DESCRIPTION "Universal TUN/TAP device driver" 40#define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>" 41 42#include <linux/module.h> 43#include <linux/errno.h> 44#include <linux/kernel.h> 45#include <linux/major.h> 46#include <linux/slab.h> 47#include <linux/poll.h> 48#include <linux/fcntl.h> 49#include <linux/init.h> 50#include <linux/skbuff.h> 51#include <linux/netdevice.h> 52#include <linux/etherdevice.h> 53#include <linux/miscdevice.h> 54#include <linux/ethtool.h> 55#include <linux/rtnetlink.h> 56#include <linux/compat.h> 57#include <linux/if.h> 58#include <linux/if_arp.h> 59#include <linux/if_ether.h> 60#include <linux/if_tun.h> 61#include <linux/crc32.h> 62#include <linux/nsproxy.h> 63#include <linux/virtio_net.h> 64#include <linux/rcupdate.h> 65#include <net/net_namespace.h> 66#include <net/netns/generic.h> 67#include <net/rtnetlink.h> 68#include <net/sock.h> 69 70#include <asm/system.h> 71#include <asm/uaccess.h> 72 73/* Uncomment to enable debugging */ 74/* #define TUN_DEBUG 1 */ 75 76#ifdef TUN_DEBUG 77static int debug; 78 79#define DBG if(tun->debug)printk 80#define DBG1 if(debug==2)printk 81#else 82#define DBG( a... ) 83#define DBG1( a... ) 84#endif 85 86#define FLT_EXACT_COUNT 8 87struct tap_filter { 88 unsigned int count; /* Number of addrs. Zero means disabled */ 89 u32 mask[2]; /* Mask of the hashed addrs */ 90 unsigned char addr[FLT_EXACT_COUNT][ETH_ALEN]; 91}; 92 93struct tun_file { 94 atomic_t count; 95 struct tun_struct *tun; 96 struct net *net; 97}; 98 99struct tun_sock; 100 101struct tun_struct { 102 struct tun_file *tfile; 103 unsigned int flags; 104 uid_t owner; 105 gid_t group; 106 107 struct net_device *dev; 108 struct fasync_struct *fasync; 109 110 struct tap_filter txflt; 111 struct socket socket; 112 struct socket_wq wq; 113 114 int vnet_hdr_sz; 115 116#ifdef TUN_DEBUG 117 int debug; 118#endif 119}; 120 121struct tun_sock { 122 struct sock sk; 123 struct tun_struct *tun; 124}; 125 126static inline struct tun_sock *tun_sk(struct sock *sk) 127{ 128 return container_of(sk, struct tun_sock, sk); 129} 130 131static int tun_attach(struct tun_struct *tun, struct file *file) 132{ 133 struct tun_file *tfile = file->private_data; 134 int err; 135 136 ASSERT_RTNL(); 137 138 netif_tx_lock_bh(tun->dev); 139 140 err = -EINVAL; 141 if (tfile->tun) 142 goto out; 143 144 err = -EBUSY; 145 if (tun->tfile) 146 goto out; 147 148 err = 0; 149 tfile->tun = tun; 150 tun->tfile = tfile; 151 tun->socket.file = file; 152 netif_carrier_on(tun->dev); 153 dev_hold(tun->dev); 154 sock_hold(tun->socket.sk); 155 atomic_inc(&tfile->count); 156 157out: 158 netif_tx_unlock_bh(tun->dev); 159 return err; 160} 161 162static void __tun_detach(struct tun_struct *tun) 163{ 164 /* Detach from net device */ 165 netif_tx_lock_bh(tun->dev); 166 netif_carrier_off(tun->dev); 167 tun->tfile = NULL; 168 tun->socket.file = NULL; 169 netif_tx_unlock_bh(tun->dev); 170 171 /* Drop read queue */ 172 skb_queue_purge(&tun->socket.sk->sk_receive_queue); 173 174 /* Drop the extra count on the net device */ 175 dev_put(tun->dev); 176} 177 178static void tun_detach(struct tun_struct *tun) 179{ 180 rtnl_lock(); 181 __tun_detach(tun); 182 rtnl_unlock(); 183} 184 185static struct tun_struct *__tun_get(struct tun_file *tfile) 186{ 187 struct tun_struct *tun = NULL; 188 189 if (atomic_inc_not_zero(&tfile->count)) 190 tun = tfile->tun; 191 192 return tun; 193} 194 195static struct tun_struct *tun_get(struct file *file) 196{ 197 return __tun_get(file->private_data); 198} 199 200static void tun_put(struct tun_struct *tun) 201{ 202 struct tun_file *tfile = tun->tfile; 203 204 if (atomic_dec_and_test(&tfile->count)) 205 tun_detach(tfile->tun); 206} 207 208/* TAP filterting */ 209static void addr_hash_set(u32 *mask, const u8 *addr) 210{ 211 int n = ether_crc(ETH_ALEN, addr) >> 26; 212 mask[n >> 5] |= (1 << (n & 31)); 213} 214 215static unsigned int addr_hash_test(const u32 *mask, const u8 *addr) 216{ 217 int n = ether_crc(ETH_ALEN, addr) >> 26; 218 return mask[n >> 5] & (1 << (n & 31)); 219} 220 221static int update_filter(struct tap_filter *filter, void __user *arg) 222{ 223 struct { u8 u[ETH_ALEN]; } *addr; 224 struct tun_filter uf; 225 int err, alen, n, nexact; 226 227 if (copy_from_user(&uf, arg, sizeof(uf))) 228 return -EFAULT; 229 230 if (!uf.count) { 231 /* Disabled */ 232 filter->count = 0; 233 return 0; 234 } 235 236 alen = ETH_ALEN * uf.count; 237 addr = kmalloc(alen, GFP_KERNEL); 238 if (!addr) 239 return -ENOMEM; 240 241 if (copy_from_user(addr, arg + sizeof(uf), alen)) { 242 err = -EFAULT; 243 goto done; 244 } 245 246 /* The filter is updated without holding any locks. Which is 247 * perfectly safe. We disable it first and in the worst 248 * case we'll accept a few undesired packets. */ 249 filter->count = 0; 250 wmb(); 251 252 /* Use first set of addresses as an exact filter */ 253 for (n = 0; n < uf.count && n < FLT_EXACT_COUNT; n++) 254 memcpy(filter->addr[n], addr[n].u, ETH_ALEN); 255 256 nexact = n; 257 258 /* Remaining multicast addresses are hashed, 259 * unicast will leave the filter disabled. */ 260 memset(filter->mask, 0, sizeof(filter->mask)); 261 for (; n < uf.count; n++) { 262 if (!is_multicast_ether_addr(addr[n].u)) { 263 err = 0; /* no filter */ 264 goto done; 265 } 266 addr_hash_set(filter->mask, addr[n].u); 267 } 268 269 /* For ALLMULTI just set the mask to all ones. 270 * This overrides the mask populated above. */ 271 if ((uf.flags & TUN_FLT_ALLMULTI)) 272 memset(filter->mask, ~0, sizeof(filter->mask)); 273 274 /* Now enable the filter */ 275 wmb(); 276 filter->count = nexact; 277 278 /* Return the number of exact filters */ 279 err = nexact; 280 281done: 282 kfree(addr); 283 return err; 284} 285 286/* Returns: 0 - drop, !=0 - accept */ 287static int run_filter(struct tap_filter *filter, const struct sk_buff *skb) 288{ 289 /* Cannot use eth_hdr(skb) here because skb_mac_hdr() is incorrect 290 * at this point. */ 291 struct ethhdr *eh = (struct ethhdr *) skb->data; 292 int i; 293 294 /* Exact match */ 295 for (i = 0; i < filter->count; i++) 296 if (!compare_ether_addr(eh->h_dest, filter->addr[i])) 297 return 1; 298 299 /* Inexact match (multicast only) */ 300 if (is_multicast_ether_addr(eh->h_dest)) 301 return addr_hash_test(filter->mask, eh->h_dest); 302 303 return 0; 304} 305 306/* 307 * Checks whether the packet is accepted or not. 308 * Returns: 0 - drop, !=0 - accept 309 */ 310static int check_filter(struct tap_filter *filter, const struct sk_buff *skb) 311{ 312 if (!filter->count) 313 return 1; 314 315 return run_filter(filter, skb); 316} 317 318/* Network device part of the driver */ 319 320static const struct ethtool_ops tun_ethtool_ops; 321 322/* Net device detach from fd. */ 323static void tun_net_uninit(struct net_device *dev) 324{ 325 struct tun_struct *tun = netdev_priv(dev); 326 struct tun_file *tfile = tun->tfile; 327 328 /* Inform the methods they need to stop using the dev. 329 */ 330 if (tfile) { 331 wake_up_all(&tun->wq.wait); 332 if (atomic_dec_and_test(&tfile->count)) 333 __tun_detach(tun); 334 } 335} 336 337static void tun_free_netdev(struct net_device *dev) 338{ 339 struct tun_struct *tun = netdev_priv(dev); 340 341 sock_put(tun->socket.sk); 342} 343 344/* Net device open. */ 345static int tun_net_open(struct net_device *dev) 346{ 347 netif_start_queue(dev); 348 return 0; 349} 350 351/* Net device close. */ 352static int tun_net_close(struct net_device *dev) 353{ 354 netif_stop_queue(dev); 355 return 0; 356} 357 358/* Net device start xmit */ 359static netdev_tx_t tun_net_xmit(struct sk_buff *skb, struct net_device *dev) 360{ 361 struct tun_struct *tun = netdev_priv(dev); 362 363 DBG(KERN_INFO "%s: tun_net_xmit %d\n", tun->dev->name, skb->len); 364 365 /* Drop packet if interface is not attached */ 366 if (!tun->tfile) 367 goto drop; 368 369 /* Drop if the filter does not like it. 370 * This is a noop if the filter is disabled. 371 * Filter can be enabled only for the TAP devices. */ 372 if (!check_filter(&tun->txflt, skb)) 373 goto drop; 374 375 if (tun->socket.sk->sk_filter && 376 sk_filter(tun->socket.sk, skb)) 377 goto drop; 378 379 if (skb_queue_len(&tun->socket.sk->sk_receive_queue) >= dev->tx_queue_len) { 380 if (!(tun->flags & TUN_ONE_QUEUE)) { 381 /* Normal queueing mode. */ 382 /* Packet scheduler handles dropping of further packets. */ 383 netif_stop_queue(dev); 384 385 /* We won't see all dropped packets individually, so overrun 386 * error is more appropriate. */ 387 dev->stats.tx_fifo_errors++; 388 } else { 389 /* Single queue mode. 390 * Driver handles dropping of all packets itself. */ 391 goto drop; 392 } 393 } 394 395 /* Orphan the skb - required as we might hang on to it 396 * for indefinite time. */ 397 skb_orphan(skb); 398 399 /* Enqueue packet */ 400 skb_queue_tail(&tun->socket.sk->sk_receive_queue, skb); 401 402 /* Notify and wake up reader process */ 403 if (tun->flags & TUN_FASYNC) 404 kill_fasync(&tun->fasync, SIGIO, POLL_IN); 405 wake_up_interruptible_poll(&tun->wq.wait, POLLIN | 406 POLLRDNORM | POLLRDBAND); 407 return NETDEV_TX_OK; 408 409drop: 410 dev->stats.tx_dropped++; 411 kfree_skb(skb); 412 return NETDEV_TX_OK; 413} 414 415static void tun_net_mclist(struct net_device *dev) 416{ 417 /* 418 * This callback is supposed to deal with mc filter in 419 * _rx_ path and has nothing to do with the _tx_ path. 420 * In rx path we always accept everything userspace gives us. 421 */ 422} 423 424#define MIN_MTU 68 425#define MAX_MTU 65535 426 427static int 428tun_net_change_mtu(struct net_device *dev, int new_mtu) 429{ 430 if (new_mtu < MIN_MTU || new_mtu + dev->hard_header_len > MAX_MTU) 431 return -EINVAL; 432 dev->mtu = new_mtu; 433 return 0; 434} 435 436static const struct net_device_ops tun_netdev_ops = { 437 .ndo_uninit = tun_net_uninit, 438 .ndo_open = tun_net_open, 439 .ndo_stop = tun_net_close, 440 .ndo_start_xmit = tun_net_xmit, 441 .ndo_change_mtu = tun_net_change_mtu, 442}; 443 444static const struct net_device_ops tap_netdev_ops = { 445 .ndo_uninit = tun_net_uninit, 446 .ndo_open = tun_net_open, 447 .ndo_stop = tun_net_close, 448 .ndo_start_xmit = tun_net_xmit, 449 .ndo_change_mtu = tun_net_change_mtu, 450 .ndo_set_multicast_list = tun_net_mclist, 451 .ndo_set_mac_address = eth_mac_addr, 452 .ndo_validate_addr = eth_validate_addr, 453}; 454 455/* Initialize net device. */ 456static void tun_net_init(struct net_device *dev) 457{ 458 struct tun_struct *tun = netdev_priv(dev); 459 460 switch (tun->flags & TUN_TYPE_MASK) { 461 case TUN_TUN_DEV: 462 dev->netdev_ops = &tun_netdev_ops; 463 464 /* Point-to-Point TUN Device */ 465 dev->hard_header_len = 0; 466 dev->addr_len = 0; 467 dev->mtu = 1500; 468 469 /* Zero header length */ 470 dev->type = ARPHRD_NONE; 471 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST; 472 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */ 473 break; 474 475 case TUN_TAP_DEV: 476 dev->netdev_ops = &tap_netdev_ops; 477 /* Ethernet TAP Device */ 478 ether_setup(dev); 479 480 random_ether_addr(dev->dev_addr); 481 482 dev->tx_queue_len = TUN_READQ_SIZE; /* We prefer our own queue length */ 483 break; 484 } 485} 486 487/* Character device part */ 488 489/* Poll */ 490static unsigned int tun_chr_poll(struct file *file, poll_table * wait) 491{ 492 struct tun_file *tfile = file->private_data; 493 struct tun_struct *tun = __tun_get(tfile); 494 struct sock *sk; 495 unsigned int mask = 0; 496 497 if (!tun) 498 return POLLERR; 499 500 sk = tun->socket.sk; 501 502 DBG(KERN_INFO "%s: tun_chr_poll\n", tun->dev->name); 503 504 poll_wait(file, &tun->wq.wait, wait); 505 506 if (!skb_queue_empty(&sk->sk_receive_queue)) 507 mask |= POLLIN | POLLRDNORM; 508 509 if (sock_writeable(sk) || 510 (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags) && 511 sock_writeable(sk))) 512 mask |= POLLOUT | POLLWRNORM; 513 514 if (tun->dev->reg_state != NETREG_REGISTERED) 515 mask = POLLERR; 516 517 tun_put(tun); 518 return mask; 519} 520 521/* prepad is the amount to reserve at front. len is length after that. 522 * linear is a hint as to how much to copy (usually headers). */ 523static inline struct sk_buff *tun_alloc_skb(struct tun_struct *tun, 524 size_t prepad, size_t len, 525 size_t linear, int noblock) 526{ 527 struct sock *sk = tun->socket.sk; 528 struct sk_buff *skb; 529 int err; 530 531 sock_update_classid(sk); 532 533 /* Under a page? Don't bother with paged skb. */ 534 if (prepad + len < PAGE_SIZE || !linear) 535 linear = len; 536 537 skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock, 538 &err); 539 if (!skb) 540 return ERR_PTR(err); 541 542 skb_reserve(skb, prepad); 543 skb_put(skb, linear); 544 skb->data_len = len - linear; 545 skb->len += len - linear; 546 547 return skb; 548} 549 550/* Get packet from user space buffer */ 551static __inline__ ssize_t tun_get_user(struct tun_struct *tun, 552 const struct iovec *iv, size_t count, 553 int noblock) 554{ 555 struct tun_pi pi = { 0, cpu_to_be16(ETH_P_IP) }; 556 struct sk_buff *skb; 557 size_t len = count, align = 0; 558 struct virtio_net_hdr gso = { 0 }; 559 int offset = 0; 560 561 if (!(tun->flags & TUN_NO_PI)) { 562 if ((len -= sizeof(pi)) > count) 563 return -EINVAL; 564 565 if (memcpy_fromiovecend((void *)&pi, iv, 0, sizeof(pi))) 566 return -EFAULT; 567 offset += sizeof(pi); 568 } 569 570 if (tun->flags & TUN_VNET_HDR) { 571 if ((len -= tun->vnet_hdr_sz) > count) 572 return -EINVAL; 573 574 if (memcpy_fromiovecend((void *)&gso, iv, offset, sizeof(gso))) 575 return -EFAULT; 576 577 if ((gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && 578 gso.csum_start + gso.csum_offset + 2 > gso.hdr_len) 579 gso.hdr_len = gso.csum_start + gso.csum_offset + 2; 580 581 if (gso.hdr_len > len) 582 return -EINVAL; 583 offset += tun->vnet_hdr_sz; 584 } 585 586 if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) { 587 align = NET_IP_ALIGN; 588 if (unlikely(len < ETH_HLEN || 589 (gso.hdr_len && gso.hdr_len < ETH_HLEN))) 590 return -EINVAL; 591 } 592 593 skb = tun_alloc_skb(tun, align, len, gso.hdr_len, noblock); 594 if (IS_ERR(skb)) { 595 if (PTR_ERR(skb) != -EAGAIN) 596 tun->dev->stats.rx_dropped++; 597 return PTR_ERR(skb); 598 } 599 600 if (skb_copy_datagram_from_iovec(skb, 0, iv, offset, len)) { 601 tun->dev->stats.rx_dropped++; 602 kfree_skb(skb); 603 return -EFAULT; 604 } 605 606 if (gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { 607 if (!skb_partial_csum_set(skb, gso.csum_start, 608 gso.csum_offset)) { 609 tun->dev->stats.rx_frame_errors++; 610 kfree_skb(skb); 611 return -EINVAL; 612 } 613 } else if (tun->flags & TUN_NOCHECKSUM) 614 skb->ip_summed = CHECKSUM_UNNECESSARY; 615 616 switch (tun->flags & TUN_TYPE_MASK) { 617 case TUN_TUN_DEV: 618 if (tun->flags & TUN_NO_PI) { 619 switch (skb->data[0] & 0xf0) { 620 case 0x40: 621 pi.proto = htons(ETH_P_IP); 622 break; 623 case 0x60: 624 pi.proto = htons(ETH_P_IPV6); 625 break; 626 default: 627 tun->dev->stats.rx_dropped++; 628 kfree_skb(skb); 629 return -EINVAL; 630 } 631 } 632 633 skb_reset_mac_header(skb); 634 skb->protocol = pi.proto; 635 skb->dev = tun->dev; 636 break; 637 case TUN_TAP_DEV: 638 skb->protocol = eth_type_trans(skb, tun->dev); 639 break; 640 }; 641 642 if (gso.gso_type != VIRTIO_NET_HDR_GSO_NONE) { 643 pr_debug("GSO!\n"); 644 switch (gso.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) { 645 case VIRTIO_NET_HDR_GSO_TCPV4: 646 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4; 647 break; 648 case VIRTIO_NET_HDR_GSO_TCPV6: 649 skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6; 650 break; 651 case VIRTIO_NET_HDR_GSO_UDP: 652 skb_shinfo(skb)->gso_type = SKB_GSO_UDP; 653 break; 654 default: 655 tun->dev->stats.rx_frame_errors++; 656 kfree_skb(skb); 657 return -EINVAL; 658 } 659 660 if (gso.gso_type & VIRTIO_NET_HDR_GSO_ECN) 661 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN; 662 663 skb_shinfo(skb)->gso_size = gso.gso_size; 664 if (skb_shinfo(skb)->gso_size == 0) { 665 tun->dev->stats.rx_frame_errors++; 666 kfree_skb(skb); 667 return -EINVAL; 668 } 669 670 /* Header must be checked, and gso_segs computed. */ 671 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY; 672 skb_shinfo(skb)->gso_segs = 0; 673 } 674 675 netif_rx_ni(skb); 676 677 tun->dev->stats.rx_packets++; 678 tun->dev->stats.rx_bytes += len; 679 680 return count; 681} 682 683static ssize_t tun_chr_aio_write(struct kiocb *iocb, const struct iovec *iv, 684 unsigned long count, loff_t pos) 685{ 686 struct file *file = iocb->ki_filp; 687 struct tun_struct *tun = tun_get(file); 688 ssize_t result; 689 690 if (!tun) 691 return -EBADFD; 692 693 DBG(KERN_INFO "%s: tun_chr_write %ld\n", tun->dev->name, count); 694 695 result = tun_get_user(tun, iv, iov_length(iv, count), 696 file->f_flags & O_NONBLOCK); 697 698 tun_put(tun); 699 return result; 700} 701 702/* Put packet to the user space buffer */ 703static __inline__ ssize_t tun_put_user(struct tun_struct *tun, 704 struct sk_buff *skb, 705 const struct iovec *iv, int len) 706{ 707 struct tun_pi pi = { 0, skb->protocol }; 708 ssize_t total = 0; 709 710 if (!(tun->flags & TUN_NO_PI)) { 711 if ((len -= sizeof(pi)) < 0) 712 return -EINVAL; 713 714 if (len < skb->len) { 715 /* Packet will be striped */ 716 pi.flags |= TUN_PKT_STRIP; 717 } 718 719 if (memcpy_toiovecend(iv, (void *) &pi, 0, sizeof(pi))) 720 return -EFAULT; 721 total += sizeof(pi); 722 } 723 724 if (tun->flags & TUN_VNET_HDR) { 725 struct virtio_net_hdr gso = { 0 }; /* no info leak */ 726 if ((len -= tun->vnet_hdr_sz) < 0) 727 return -EINVAL; 728 729 if (skb_is_gso(skb)) { 730 struct skb_shared_info *sinfo = skb_shinfo(skb); 731 732 /* This is a hint as to how much should be linear. */ 733 gso.hdr_len = skb_headlen(skb); 734 gso.gso_size = sinfo->gso_size; 735 if (sinfo->gso_type & SKB_GSO_TCPV4) 736 gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV4; 737 else if (sinfo->gso_type & SKB_GSO_TCPV6) 738 gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV6; 739 else if (sinfo->gso_type & SKB_GSO_UDP) 740 gso.gso_type = VIRTIO_NET_HDR_GSO_UDP; 741 else { 742 printk(KERN_ERR "tun: unexpected GSO type: " 743 "0x%x, gso_size %d, hdr_len %d\n", 744 sinfo->gso_type, gso.gso_size, 745 gso.hdr_len); 746 print_hex_dump(KERN_ERR, "tun: ", 747 DUMP_PREFIX_NONE, 748 16, 1, skb->head, 749 min((int)gso.hdr_len, 64), true); 750 WARN_ON_ONCE(1); 751 return -EINVAL; 752 } 753 if (sinfo->gso_type & SKB_GSO_TCP_ECN) 754 gso.gso_type |= VIRTIO_NET_HDR_GSO_ECN; 755 } else 756 gso.gso_type = VIRTIO_NET_HDR_GSO_NONE; 757 758 if (skb->ip_summed == CHECKSUM_PARTIAL) { 759 gso.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; 760 gso.csum_start = skb->csum_start - skb_headroom(skb); 761 gso.csum_offset = skb->csum_offset; 762 } /* else everything is zero */ 763 764 if (unlikely(memcpy_toiovecend(iv, (void *)&gso, total, 765 sizeof(gso)))) 766 return -EFAULT; 767 total += tun->vnet_hdr_sz; 768 } 769 770 len = min_t(int, skb->len, len); 771 772 skb_copy_datagram_const_iovec(skb, 0, iv, total, len); 773 total += skb->len; 774 775 tun->dev->stats.tx_packets++; 776 tun->dev->stats.tx_bytes += len; 777 778 return total; 779} 780 781static ssize_t tun_do_read(struct tun_struct *tun, 782 struct kiocb *iocb, const struct iovec *iv, 783 ssize_t len, int noblock) 784{ 785 DECLARE_WAITQUEUE(wait, current); 786 struct sk_buff *skb; 787 ssize_t ret = 0; 788 789 DBG(KERN_INFO "%s: tun_chr_read\n", tun->dev->name); 790 791 add_wait_queue(&tun->wq.wait, &wait); 792 while (len) { 793 current->state = TASK_INTERRUPTIBLE; 794 795 /* Read frames from the queue */ 796 if (!(skb=skb_dequeue(&tun->socket.sk->sk_receive_queue))) { 797 if (noblock) { 798 ret = -EAGAIN; 799 break; 800 } 801 if (signal_pending(current)) { 802 ret = -ERESTARTSYS; 803 break; 804 } 805 if (tun->dev->reg_state != NETREG_REGISTERED) { 806 ret = -EIO; 807 break; 808 } 809 810 /* Nothing to read, let's sleep */ 811 schedule(); 812 continue; 813 } 814 netif_wake_queue(tun->dev); 815 816 ret = tun_put_user(tun, skb, iv, len); 817 kfree_skb(skb); 818 break; 819 } 820 821 current->state = TASK_RUNNING; 822 remove_wait_queue(&tun->wq.wait, &wait); 823 824 return ret; 825} 826 827static ssize_t tun_chr_aio_read(struct kiocb *iocb, const struct iovec *iv, 828 unsigned long count, loff_t pos) 829{ 830 struct file *file = iocb->ki_filp; 831 struct tun_file *tfile = file->private_data; 832 struct tun_struct *tun = __tun_get(tfile); 833 ssize_t len, ret; 834 835 if (!tun) 836 return -EBADFD; 837 len = iov_length(iv, count); 838 if (len < 0) { 839 ret = -EINVAL; 840 goto out; 841 } 842 843 ret = tun_do_read(tun, iocb, iv, len, file->f_flags & O_NONBLOCK); 844 ret = min_t(ssize_t, ret, len); 845out: 846 tun_put(tun); 847 return ret; 848} 849 850static void tun_setup(struct net_device *dev) 851{ 852 struct tun_struct *tun = netdev_priv(dev); 853 854 tun->owner = -1; 855 tun->group = -1; 856 857 dev->ethtool_ops = &tun_ethtool_ops; 858 dev->destructor = tun_free_netdev; 859} 860 861/* Trivial set of netlink ops to allow deleting tun or tap 862 * device with netlink. 863 */ 864static int tun_validate(struct nlattr *tb[], struct nlattr *data[]) 865{ 866 return -EINVAL; 867} 868 869static struct rtnl_link_ops tun_link_ops __read_mostly = { 870 .kind = DRV_NAME, 871 .priv_size = sizeof(struct tun_struct), 872 .setup = tun_setup, 873 .validate = tun_validate, 874}; 875 876static void tun_sock_write_space(struct sock *sk) 877{ 878 struct tun_struct *tun; 879 wait_queue_head_t *wqueue; 880 881 if (!sock_writeable(sk)) 882 return; 883 884 if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags)) 885 return; 886 887 wqueue = sk_sleep(sk); 888 if (wqueue && waitqueue_active(wqueue)) 889 wake_up_interruptible_sync_poll(wqueue, POLLOUT | 890 POLLWRNORM | POLLWRBAND); 891 892 tun = tun_sk(sk)->tun; 893 kill_fasync(&tun->fasync, SIGIO, POLL_OUT); 894} 895 896static void tun_sock_destruct(struct sock *sk) 897{ 898 free_netdev(tun_sk(sk)->tun->dev); 899} 900 901static int tun_sendmsg(struct kiocb *iocb, struct socket *sock, 902 struct msghdr *m, size_t total_len) 903{ 904 struct tun_struct *tun = container_of(sock, struct tun_struct, socket); 905 return tun_get_user(tun, m->msg_iov, total_len, 906 m->msg_flags & MSG_DONTWAIT); 907} 908 909static int tun_recvmsg(struct kiocb *iocb, struct socket *sock, 910 struct msghdr *m, size_t total_len, 911 int flags) 912{ 913 struct tun_struct *tun = container_of(sock, struct tun_struct, socket); 914 int ret; 915 if (flags & ~(MSG_DONTWAIT|MSG_TRUNC)) 916 return -EINVAL; 917 ret = tun_do_read(tun, iocb, m->msg_iov, total_len, 918 flags & MSG_DONTWAIT); 919 if (ret > total_len) { 920 m->msg_flags |= MSG_TRUNC; 921 ret = flags & MSG_TRUNC ? ret : total_len; 922 } 923 return ret; 924} 925 926/* Ops structure to mimic raw sockets with tun */ 927static const struct proto_ops tun_socket_ops = { 928 .sendmsg = tun_sendmsg, 929 .recvmsg = tun_recvmsg, 930}; 931 932static struct proto tun_proto = { 933 .name = "tun", 934 .owner = THIS_MODULE, 935 .obj_size = sizeof(struct tun_sock), 936}; 937 938static int tun_flags(struct tun_struct *tun) 939{ 940 int flags = 0; 941 942 if (tun->flags & TUN_TUN_DEV) 943 flags |= IFF_TUN; 944 else 945 flags |= IFF_TAP; 946 947 if (tun->flags & TUN_NO_PI) 948 flags |= IFF_NO_PI; 949 950 if (tun->flags & TUN_ONE_QUEUE) 951 flags |= IFF_ONE_QUEUE; 952 953 if (tun->flags & TUN_VNET_HDR) 954 flags |= IFF_VNET_HDR; 955 956 return flags; 957} 958 959static ssize_t tun_show_flags(struct device *dev, struct device_attribute *attr, 960 char *buf) 961{ 962 struct tun_struct *tun = netdev_priv(to_net_dev(dev)); 963 return sprintf(buf, "0x%x\n", tun_flags(tun)); 964} 965 966static ssize_t tun_show_owner(struct device *dev, struct device_attribute *attr, 967 char *buf) 968{ 969 struct tun_struct *tun = netdev_priv(to_net_dev(dev)); 970 return sprintf(buf, "%d\n", tun->owner); 971} 972 973static ssize_t tun_show_group(struct device *dev, struct device_attribute *attr, 974 char *buf) 975{ 976 struct tun_struct *tun = netdev_priv(to_net_dev(dev)); 977 return sprintf(buf, "%d\n", tun->group); 978} 979 980static DEVICE_ATTR(tun_flags, 0444, tun_show_flags, NULL); 981static DEVICE_ATTR(owner, 0444, tun_show_owner, NULL); 982static DEVICE_ATTR(group, 0444, tun_show_group, NULL); 983 984static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr) 985{ 986 struct sock *sk; 987 struct tun_struct *tun; 988 struct net_device *dev; 989 int err; 990 991 dev = __dev_get_by_name(net, ifr->ifr_name); 992 if (dev) { 993 const struct cred *cred = current_cred(); 994 995 if (ifr->ifr_flags & IFF_TUN_EXCL) 996 return -EBUSY; 997 if ((ifr->ifr_flags & IFF_TUN) && dev->netdev_ops == &tun_netdev_ops) 998 tun = netdev_priv(dev); 999 else if ((ifr->ifr_flags & IFF_TAP) && dev->netdev_ops == &tap_netdev_ops) 1000 tun = netdev_priv(dev); 1001 else 1002 return -EINVAL; 1003 1004 if (((tun->owner != -1 && cred->euid != tun->owner) || 1005 (tun->group != -1 && !in_egroup_p(tun->group))) && 1006 !capable(CAP_NET_ADMIN)) 1007 return -EPERM; 1008 err = security_tun_dev_attach(tun->socket.sk); 1009 if (err < 0) 1010 return err; 1011 1012 err = tun_attach(tun, file); 1013 if (err < 0) 1014 return err; 1015 } 1016 else { 1017 char *name; 1018 unsigned long flags = 0; 1019 1020 if (!capable(CAP_NET_ADMIN)) 1021 return -EPERM; 1022 err = security_tun_dev_create(); 1023 if (err < 0) 1024 return err; 1025 1026 /* Set dev type */ 1027 if (ifr->ifr_flags & IFF_TUN) { 1028 /* TUN device */ 1029 flags |= TUN_TUN_DEV; 1030 name = "tun%d"; 1031 } else if (ifr->ifr_flags & IFF_TAP) { 1032 /* TAP device */ 1033 flags |= TUN_TAP_DEV; 1034 name = "tap%d"; 1035 } else 1036 return -EINVAL; 1037 1038 if (*ifr->ifr_name) 1039 name = ifr->ifr_name; 1040 1041 dev = alloc_netdev(sizeof(struct tun_struct), name, 1042 tun_setup); 1043 if (!dev) 1044 return -ENOMEM; 1045 1046 dev_net_set(dev, net); 1047 dev->rtnl_link_ops = &tun_link_ops; 1048 1049 tun = netdev_priv(dev); 1050 tun->dev = dev; 1051 tun->flags = flags; 1052 tun->txflt.count = 0; 1053 tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr); 1054 1055 err = -ENOMEM; 1056 sk = sk_alloc(net, AF_UNSPEC, GFP_KERNEL, &tun_proto); 1057 if (!sk) 1058 goto err_free_dev; 1059 1060 tun->socket.wq = &tun->wq; 1061 init_waitqueue_head(&tun->wq.wait); 1062 tun->socket.ops = &tun_socket_ops; 1063 sock_init_data(&tun->socket, sk); 1064 sk->sk_write_space = tun_sock_write_space; 1065 sk->sk_sndbuf = INT_MAX; 1066 1067 tun_sk(sk)->tun = tun; 1068 1069 security_tun_dev_post_create(sk); 1070 1071 tun_net_init(dev); 1072 1073 if (strchr(dev->name, '%')) { 1074 err = dev_alloc_name(dev, dev->name); 1075 if (err < 0) 1076 goto err_free_sk; 1077 } 1078 1079 err = register_netdevice(tun->dev); 1080 if (err < 0) 1081 goto err_free_sk; 1082 1083 if (device_create_file(&tun->dev->dev, &dev_attr_tun_flags) || 1084 device_create_file(&tun->dev->dev, &dev_attr_owner) || 1085 device_create_file(&tun->dev->dev, &dev_attr_group)) 1086 printk(KERN_ERR "Failed to create tun sysfs files\n"); 1087 1088 sk->sk_destruct = tun_sock_destruct; 1089 1090 err = tun_attach(tun, file); 1091 if (err < 0) 1092 goto failed; 1093 } 1094 1095 DBG(KERN_INFO "%s: tun_set_iff\n", tun->dev->name); 1096 1097 if (ifr->ifr_flags & IFF_NO_PI) 1098 tun->flags |= TUN_NO_PI; 1099 else 1100 tun->flags &= ~TUN_NO_PI; 1101 1102 if (ifr->ifr_flags & IFF_ONE_QUEUE) 1103 tun->flags |= TUN_ONE_QUEUE; 1104 else 1105 tun->flags &= ~TUN_ONE_QUEUE; 1106 1107 if (ifr->ifr_flags & IFF_VNET_HDR) 1108 tun->flags |= TUN_VNET_HDR; 1109 else 1110 tun->flags &= ~TUN_VNET_HDR; 1111 1112 /* Make sure persistent devices do not get stuck in 1113 * xoff state. 1114 */ 1115 if (netif_running(tun->dev)) 1116 netif_wake_queue(tun->dev); 1117 1118 strcpy(ifr->ifr_name, tun->dev->name); 1119 return 0; 1120 1121 err_free_sk: 1122 sock_put(sk); 1123 err_free_dev: 1124 free_netdev(dev); 1125 failed: 1126 return err; 1127} 1128 1129static int tun_get_iff(struct net *net, struct tun_struct *tun, 1130 struct ifreq *ifr) 1131{ 1132 DBG(KERN_INFO "%s: tun_get_iff\n", tun->dev->name); 1133 1134 strcpy(ifr->ifr_name, tun->dev->name); 1135 1136 ifr->ifr_flags = tun_flags(tun); 1137 1138 return 0; 1139} 1140 1141/* This is like a cut-down ethtool ops, except done via tun fd so no 1142 * privs required. */ 1143static int set_offload(struct net_device *dev, unsigned long arg) 1144{ 1145 unsigned int old_features, features; 1146 1147 old_features = dev->features; 1148 /* Unset features, set them as we chew on the arg. */ 1149 features = (old_features & ~(NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST 1150 |NETIF_F_TSO_ECN|NETIF_F_TSO|NETIF_F_TSO6 1151 |NETIF_F_UFO)); 1152 1153 if (arg & TUN_F_CSUM) { 1154 features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST; 1155 arg &= ~TUN_F_CSUM; 1156 1157 if (arg & (TUN_F_TSO4|TUN_F_TSO6)) { 1158 if (arg & TUN_F_TSO_ECN) { 1159 features |= NETIF_F_TSO_ECN; 1160 arg &= ~TUN_F_TSO_ECN; 1161 } 1162 if (arg & TUN_F_TSO4) 1163 features |= NETIF_F_TSO; 1164 if (arg & TUN_F_TSO6) 1165 features |= NETIF_F_TSO6; 1166 arg &= ~(TUN_F_TSO4|TUN_F_TSO6); 1167 } 1168 1169 if (arg & TUN_F_UFO) { 1170 features |= NETIF_F_UFO; 1171 arg &= ~TUN_F_UFO; 1172 } 1173 } 1174 1175 /* This gives the user a way to test for new features in future by 1176 * trying to set them. */ 1177 if (arg) 1178 return -EINVAL; 1179 1180 dev->features = features; 1181 if (old_features != dev->features) 1182 netdev_features_change(dev); 1183 1184 return 0; 1185} 1186 1187static long __tun_chr_ioctl(struct file *file, unsigned int cmd, 1188 unsigned long arg, int ifreq_len) 1189{ 1190 struct tun_file *tfile = file->private_data; 1191 struct tun_struct *tun; 1192 void __user* argp = (void __user*)arg; 1193 struct sock_fprog fprog; 1194 struct ifreq ifr; 1195 int sndbuf; 1196 int vnet_hdr_sz; 1197 int ret; 1198 1199 if (cmd == TUNSETIFF || _IOC_TYPE(cmd) == 0x89) 1200 if (copy_from_user(&ifr, argp, ifreq_len)) 1201 return -EFAULT; 1202 1203 if (cmd == TUNGETFEATURES) { 1204 /* Currently this just means: "what IFF flags are valid?". 1205 * This is needed because we never checked for invalid flags on 1206 * TUNSETIFF. */ 1207 return put_user(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE | 1208 IFF_VNET_HDR, 1209 (unsigned int __user*)argp); 1210 } 1211 1212 rtnl_lock(); 1213 1214 tun = __tun_get(tfile); 1215 if (cmd == TUNSETIFF && !tun) { 1216 ifr.ifr_name[IFNAMSIZ-1] = '\0'; 1217 1218 ret = tun_set_iff(tfile->net, file, &ifr); 1219 1220 if (ret) 1221 goto unlock; 1222 1223 if (copy_to_user(argp, &ifr, ifreq_len)) 1224 ret = -EFAULT; 1225 goto unlock; 1226 } 1227 1228 ret = -EBADFD; 1229 if (!tun) 1230 goto unlock; 1231 1232 DBG(KERN_INFO "%s: tun_chr_ioctl cmd %d\n", tun->dev->name, cmd); 1233 1234 ret = 0; 1235 switch (cmd) { 1236 case TUNGETIFF: 1237 ret = tun_get_iff(current->nsproxy->net_ns, tun, &ifr); 1238 if (ret) 1239 break; 1240 1241 if (copy_to_user(argp, &ifr, ifreq_len)) 1242 ret = -EFAULT; 1243 break; 1244 1245 case TUNSETNOCSUM: 1246 /* Disable/Enable checksum */ 1247 if (arg) 1248 tun->flags |= TUN_NOCHECKSUM; 1249 else 1250 tun->flags &= ~TUN_NOCHECKSUM; 1251 1252 DBG(KERN_INFO "%s: checksum %s\n", 1253 tun->dev->name, arg ? "disabled" : "enabled"); 1254 break; 1255 1256 case TUNSETPERSIST: 1257 /* Disable/Enable persist mode */ 1258 if (arg) 1259 tun->flags |= TUN_PERSIST; 1260 else 1261 tun->flags &= ~TUN_PERSIST; 1262 1263 DBG(KERN_INFO "%s: persist %s\n", 1264 tun->dev->name, arg ? "enabled" : "disabled"); 1265 break; 1266 1267 case TUNSETOWNER: 1268 /* Set owner of the device */ 1269 tun->owner = (uid_t) arg; 1270 1271 DBG(KERN_INFO "%s: owner set to %d\n", tun->dev->name, tun->owner); 1272 break; 1273 1274 case TUNSETGROUP: 1275 /* Set group of the device */ 1276 tun->group= (gid_t) arg; 1277 1278 DBG(KERN_INFO "%s: group set to %d\n", tun->dev->name, tun->group); 1279 break; 1280 1281 case TUNSETLINK: 1282 /* Only allow setting the type when the interface is down */ 1283 if (tun->dev->flags & IFF_UP) { 1284 DBG(KERN_INFO "%s: Linktype set failed because interface is up\n", 1285 tun->dev->name); 1286 ret = -EBUSY; 1287 } else { 1288 tun->dev->type = (int) arg; 1289 DBG(KERN_INFO "%s: linktype set to %d\n", tun->dev->name, tun->dev->type); 1290 ret = 0; 1291 } 1292 break; 1293 1294#ifdef TUN_DEBUG 1295 case TUNSETDEBUG: 1296 tun->debug = arg; 1297 break; 1298#endif 1299 case TUNSETOFFLOAD: 1300 ret = set_offload(tun->dev, arg); 1301 break; 1302 1303 case TUNSETTXFILTER: 1304 /* Can be set only for TAPs */ 1305 ret = -EINVAL; 1306 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) 1307 break; 1308 ret = update_filter(&tun->txflt, (void __user *)arg); 1309 break; 1310 1311 case SIOCGIFHWADDR: 1312 /* Get hw addres */ 1313 memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN); 1314 ifr.ifr_hwaddr.sa_family = tun->dev->type; 1315 if (copy_to_user(argp, &ifr, ifreq_len)) 1316 ret = -EFAULT; 1317 break; 1318 1319 case SIOCSIFHWADDR: 1320 /* Set hw address */ 1321 DBG(KERN_DEBUG "%s: set hw address: %pM\n", 1322 tun->dev->name, ifr.ifr_hwaddr.sa_data); 1323 1324 ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr); 1325 break; 1326 1327 case TUNGETSNDBUF: 1328 sndbuf = tun->socket.sk->sk_sndbuf; 1329 if (copy_to_user(argp, &sndbuf, sizeof(sndbuf))) 1330 ret = -EFAULT; 1331 break; 1332 1333 case TUNSETSNDBUF: 1334 if (copy_from_user(&sndbuf, argp, sizeof(sndbuf))) { 1335 ret = -EFAULT; 1336 break; 1337 } 1338 1339 tun->socket.sk->sk_sndbuf = sndbuf; 1340 break; 1341 1342 case TUNGETVNETHDRSZ: 1343 vnet_hdr_sz = tun->vnet_hdr_sz; 1344 if (copy_to_user(argp, &vnet_hdr_sz, sizeof(vnet_hdr_sz))) 1345 ret = -EFAULT; 1346 break; 1347 1348 case TUNSETVNETHDRSZ: 1349 if (copy_from_user(&vnet_hdr_sz, argp, sizeof(vnet_hdr_sz))) { 1350 ret = -EFAULT; 1351 break; 1352 } 1353 if (vnet_hdr_sz < (int)sizeof(struct virtio_net_hdr)) { 1354 ret = -EINVAL; 1355 break; 1356 } 1357 1358 tun->vnet_hdr_sz = vnet_hdr_sz; 1359 break; 1360 1361 case TUNATTACHFILTER: 1362 /* Can be set only for TAPs */ 1363 ret = -EINVAL; 1364 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) 1365 break; 1366 ret = -EFAULT; 1367 if (copy_from_user(&fprog, argp, sizeof(fprog))) 1368 break; 1369 1370 ret = sk_attach_filter(&fprog, tun->socket.sk); 1371 break; 1372 1373 case TUNDETACHFILTER: 1374 /* Can be set only for TAPs */ 1375 ret = -EINVAL; 1376 if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) 1377 break; 1378 ret = sk_detach_filter(tun->socket.sk); 1379 break; 1380 1381 default: 1382 ret = -EINVAL; 1383 break; 1384 } 1385 1386unlock: 1387 rtnl_unlock(); 1388 if (tun) 1389 tun_put(tun); 1390 return ret; 1391} 1392 1393static long tun_chr_ioctl(struct file *file, 1394 unsigned int cmd, unsigned long arg) 1395{ 1396 return __tun_chr_ioctl(file, cmd, arg, sizeof (struct ifreq)); 1397} 1398 1399#ifdef CONFIG_COMPAT 1400static long tun_chr_compat_ioctl(struct file *file, 1401 unsigned int cmd, unsigned long arg) 1402{ 1403 switch (cmd) { 1404 case TUNSETIFF: 1405 case TUNGETIFF: 1406 case TUNSETTXFILTER: 1407 case TUNGETSNDBUF: 1408 case TUNSETSNDBUF: 1409 case SIOCGIFHWADDR: 1410 case SIOCSIFHWADDR: 1411 arg = (unsigned long)compat_ptr(arg); 1412 break; 1413 default: 1414 arg = (compat_ulong_t)arg; 1415 break; 1416 } 1417 1418 /* 1419 * compat_ifreq is shorter than ifreq, so we must not access beyond 1420 * the end of that structure. All fields that are used in this 1421 * driver are compatible though, we don't need to convert the 1422 * contents. 1423 */ 1424 return __tun_chr_ioctl(file, cmd, arg, sizeof(struct compat_ifreq)); 1425} 1426#endif /* CONFIG_COMPAT */ 1427 1428static int tun_chr_fasync(int fd, struct file *file, int on) 1429{ 1430 struct tun_struct *tun = tun_get(file); 1431 int ret; 1432 1433 if (!tun) 1434 return -EBADFD; 1435 1436 DBG(KERN_INFO "%s: tun_chr_fasync %d\n", tun->dev->name, on); 1437 1438 if ((ret = fasync_helper(fd, file, on, &tun->fasync)) < 0) 1439 goto out; 1440 1441 if (on) { 1442 ret = __f_setown(file, task_pid(current), PIDTYPE_PID, 0); 1443 if (ret) 1444 goto out; 1445 tun->flags |= TUN_FASYNC; 1446 } else 1447 tun->flags &= ~TUN_FASYNC; 1448 ret = 0; 1449out: 1450 tun_put(tun); 1451 return ret; 1452} 1453 1454static int tun_chr_open(struct inode *inode, struct file * file) 1455{ 1456 struct tun_file *tfile; 1457 1458 DBG1(KERN_INFO "tunX: tun_chr_open\n"); 1459 1460 tfile = kmalloc(sizeof(*tfile), GFP_KERNEL); 1461 if (!tfile) 1462 return -ENOMEM; 1463 atomic_set(&tfile->count, 0); 1464 tfile->tun = NULL; 1465 tfile->net = get_net(current->nsproxy->net_ns); 1466 file->private_data = tfile; 1467 return 0; 1468} 1469 1470static int tun_chr_close(struct inode *inode, struct file *file) 1471{ 1472 struct tun_file *tfile = file->private_data; 1473 struct tun_struct *tun; 1474 1475 tun = __tun_get(tfile); 1476 if (tun) { 1477 struct net_device *dev = tun->dev; 1478 1479 DBG(KERN_INFO "%s: tun_chr_close\n", dev->name); 1480 1481 __tun_detach(tun); 1482 1483 /* If desirable, unregister the netdevice. */ 1484 if (!(tun->flags & TUN_PERSIST)) { 1485 rtnl_lock(); 1486 if (dev->reg_state == NETREG_REGISTERED) 1487 unregister_netdevice(dev); 1488 rtnl_unlock(); 1489 } 1490 } 1491 1492 tun = tfile->tun; 1493 if (tun) 1494 sock_put(tun->socket.sk); 1495 1496 put_net(tfile->net); 1497 kfree(tfile); 1498 1499 return 0; 1500} 1501 1502static const struct file_operations tun_fops = { 1503 .owner = THIS_MODULE, 1504 .llseek = no_llseek, 1505 .read = do_sync_read, 1506 .aio_read = tun_chr_aio_read, 1507 .write = do_sync_write, 1508 .aio_write = tun_chr_aio_write, 1509 .poll = tun_chr_poll, 1510 .unlocked_ioctl = tun_chr_ioctl, 1511#ifdef CONFIG_COMPAT 1512 .compat_ioctl = tun_chr_compat_ioctl, 1513#endif 1514 .open = tun_chr_open, 1515 .release = tun_chr_close, 1516 .fasync = tun_chr_fasync 1517}; 1518 1519static struct miscdevice tun_miscdev = { 1520 .minor = TUN_MINOR, 1521 .name = "tun", 1522 .nodename = "net/tun", 1523 .fops = &tun_fops, 1524}; 1525 1526/* ethtool interface */ 1527 1528static int tun_get_settings(struct net_device *dev, struct ethtool_cmd *cmd) 1529{ 1530 cmd->supported = 0; 1531 cmd->advertising = 0; 1532 cmd->speed = SPEED_10; 1533 cmd->duplex = DUPLEX_FULL; 1534 cmd->port = PORT_TP; 1535 cmd->phy_address = 0; 1536 cmd->transceiver = XCVR_INTERNAL; 1537 cmd->autoneg = AUTONEG_DISABLE; 1538 cmd->maxtxpkt = 0; 1539 cmd->maxrxpkt = 0; 1540 return 0; 1541} 1542 1543static void tun_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info) 1544{ 1545 struct tun_struct *tun = netdev_priv(dev); 1546 1547 strcpy(info->driver, DRV_NAME); 1548 strcpy(info->version, DRV_VERSION); 1549 strcpy(info->fw_version, "N/A"); 1550 1551 switch (tun->flags & TUN_TYPE_MASK) { 1552 case TUN_TUN_DEV: 1553 strcpy(info->bus_info, "tun"); 1554 break; 1555 case TUN_TAP_DEV: 1556 strcpy(info->bus_info, "tap"); 1557 break; 1558 } 1559} 1560 1561static u32 tun_get_msglevel(struct net_device *dev) 1562{ 1563#ifdef TUN_DEBUG 1564 struct tun_struct *tun = netdev_priv(dev); 1565 return tun->debug; 1566#else 1567 return -EOPNOTSUPP; 1568#endif 1569} 1570 1571static void tun_set_msglevel(struct net_device *dev, u32 value) 1572{ 1573#ifdef TUN_DEBUG 1574 struct tun_struct *tun = netdev_priv(dev); 1575 tun->debug = value; 1576#endif 1577} 1578 1579static u32 tun_get_rx_csum(struct net_device *dev) 1580{ 1581 struct tun_struct *tun = netdev_priv(dev); 1582 return (tun->flags & TUN_NOCHECKSUM) == 0; 1583} 1584 1585static int tun_set_rx_csum(struct net_device *dev, u32 data) 1586{ 1587 struct tun_struct *tun = netdev_priv(dev); 1588 if (data) 1589 tun->flags &= ~TUN_NOCHECKSUM; 1590 else 1591 tun->flags |= TUN_NOCHECKSUM; 1592 return 0; 1593} 1594 1595static const struct ethtool_ops tun_ethtool_ops = { 1596 .get_settings = tun_get_settings, 1597 .get_drvinfo = tun_get_drvinfo, 1598 .get_msglevel = tun_get_msglevel, 1599 .set_msglevel = tun_set_msglevel, 1600 .get_link = ethtool_op_get_link, 1601 .get_rx_csum = tun_get_rx_csum, 1602 .set_rx_csum = tun_set_rx_csum 1603}; 1604 1605 1606static int __init tun_init(void) 1607{ 1608 int ret = 0; 1609 1610 printk(KERN_INFO "tun: %s, %s\n", DRV_DESCRIPTION, DRV_VERSION); 1611 printk(KERN_INFO "tun: %s\n", DRV_COPYRIGHT); 1612 1613 ret = rtnl_link_register(&tun_link_ops); 1614 if (ret) { 1615 printk(KERN_ERR "tun: Can't register link_ops\n"); 1616 goto err_linkops; 1617 } 1618 1619 ret = misc_register(&tun_miscdev); 1620 if (ret) { 1621 printk(KERN_ERR "tun: Can't register misc device %d\n", TUN_MINOR); 1622 goto err_misc; 1623 } 1624 return 0; 1625err_misc: 1626 rtnl_link_unregister(&tun_link_ops); 1627err_linkops: 1628 return ret; 1629} 1630 1631static void tun_cleanup(void) 1632{ 1633 misc_deregister(&tun_miscdev); 1634 rtnl_link_unregister(&tun_link_ops); 1635} 1636 1637/* Get an underlying socket object from tun file. Returns error unless file is 1638 * attached to a device. The returned object works like a packet socket, it 1639 * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for 1640 * holding a reference to the file for as long as the socket is in use. */ 1641struct socket *tun_get_socket(struct file *file) 1642{ 1643 struct tun_struct *tun; 1644 if (file->f_op != &tun_fops) 1645 return ERR_PTR(-EINVAL); 1646 tun = tun_get(file); 1647 if (!tun) 1648 return ERR_PTR(-EBADFD); 1649 tun_put(tun); 1650 return &tun->socket; 1651} 1652EXPORT_SYMBOL_GPL(tun_get_socket); 1653 1654module_init(tun_init); 1655module_exit(tun_cleanup); 1656MODULE_DESCRIPTION(DRV_DESCRIPTION); 1657MODULE_AUTHOR(DRV_COPYRIGHT); 1658MODULE_LICENSE("GPL"); 1659MODULE_ALIAS_MISCDEV(TUN_MINOR); 1660MODULE_ALIAS("devname:net/tun"); 1661