1#include <linux/etherdevice.h> 2#include <linux/if_macvlan.h> 3#include <linux/interrupt.h> 4#include <linux/nsproxy.h> 5#include <linux/compat.h> 6#include <linux/if_tun.h> 7#include <linux/module.h> 8#include <linux/skbuff.h> 9#include <linux/cache.h> 10#include <linux/sched.h> 11#include <linux/types.h> 12#include <linux/slab.h> 13#include <linux/init.h> 14#include <linux/wait.h> 15#include <linux/cdev.h> 16#include <linux/fs.h> 17 18#include <net/net_namespace.h> 19#include <net/rtnetlink.h> 20#include <net/sock.h> 21#include <linux/virtio_net.h> 22 23/* 24 * A macvtap queue is the central object of this driver, it connects 25 * an open character device to a macvlan interface. There can be 26 * multiple queues on one interface, which map back to queues 27 * implemented in hardware on the underlying device. 28 * 29 * macvtap_proto is used to allocate queues through the sock allocation 30 * mechanism. 31 * 32 * TODO: multiqueue support is currently not implemented, even though 33 * macvtap is basically prepared for that. We will need to add this 34 * here as well as in virtio-net and qemu to get line rate on 10gbit 35 * adapters from a guest. 36 */ 37struct macvtap_queue { 38 struct sock sk; 39 struct socket sock; 40 struct socket_wq wq; 41 int vnet_hdr_sz; 42 struct macvlan_dev *vlan; 43 struct file *file; 44 unsigned int flags; 45}; 46 47static struct proto macvtap_proto = { 48 .name = "macvtap", 49 .owner = THIS_MODULE, 50 .obj_size = sizeof (struct macvtap_queue), 51}; 52 53/* 54 * Minor number matches netdev->ifindex, so need a potentially 55 * large value. This also makes it possible to split the 56 * tap functionality out again in the future by offering it 57 * from other drivers besides macvtap. As long as every device 58 * only has one tap, the interface numbers assure that the 59 * device nodes are unique. 60 */ 61static dev_t macvtap_major; 62#define MACVTAP_NUM_DEVS 65536 63static struct class *macvtap_class; 64static struct cdev macvtap_cdev; 65 66static const struct proto_ops macvtap_socket_ops; 67 68/* 69 * RCU usage: 70 * The macvtap_queue and the macvlan_dev are loosely coupled, the 71 * pointers from one to the other can only be read while rcu_read_lock 72 * or macvtap_lock is held. 73 * 74 * Both the file and the macvlan_dev hold a reference on the macvtap_queue 75 * through sock_hold(&q->sk). When the macvlan_dev goes away first, 76 * q->vlan becomes inaccessible. When the files gets closed, 77 * macvtap_get_queue() fails. 78 * 79 * There may still be references to the struct sock inside of the 80 * queue from outbound SKBs, but these never reference back to the 81 * file or the dev. The data structure is freed through __sk_free 82 * when both our references and any pending SKBs are gone. 83 */ 84static DEFINE_SPINLOCK(macvtap_lock); 85 86/* 87 * Choose the next free queue, for now there is only one 88 */ 89static int macvtap_set_queue(struct net_device *dev, struct file *file, 90 struct macvtap_queue *q) 91{ 92 struct macvlan_dev *vlan = netdev_priv(dev); 93 int err = -EBUSY; 94 95 spin_lock(&macvtap_lock); 96 if (rcu_dereference(vlan->tap)) 97 goto out; 98 99 err = 0; 100 rcu_assign_pointer(q->vlan, vlan); 101 rcu_assign_pointer(vlan->tap, q); 102 sock_hold(&q->sk); 103 104 q->file = file; 105 file->private_data = q; 106 107out: 108 spin_unlock(&macvtap_lock); 109 return err; 110} 111 112/* 113 * The file owning the queue got closed, give up both 114 * the reference that the files holds as well as the 115 * one from the macvlan_dev if that still exists. 116 * 117 * Using the spinlock makes sure that we don't get 118 * to the queue again after destroying it. 119 */ 120static void macvtap_put_queue(struct macvtap_queue *q) 121{ 122 struct macvlan_dev *vlan; 123 124 spin_lock(&macvtap_lock); 125 vlan = rcu_dereference(q->vlan); 126 if (vlan) { 127 rcu_assign_pointer(vlan->tap, NULL); 128 rcu_assign_pointer(q->vlan, NULL); 129 sock_put(&q->sk); 130 } 131 132 spin_unlock(&macvtap_lock); 133 134 synchronize_rcu(); 135 sock_put(&q->sk); 136} 137 138/* 139 * Since we only support one queue, just dereference the pointer. 140 */ 141static struct macvtap_queue *macvtap_get_queue(struct net_device *dev, 142 struct sk_buff *skb) 143{ 144 struct macvlan_dev *vlan = netdev_priv(dev); 145 146 return rcu_dereference(vlan->tap); 147} 148 149/* 150 * The net_device is going away, give up the reference 151 * that it holds on the queue (all the queues one day) 152 * and safely set the pointer from the queues to NULL. 153 */ 154static void macvtap_del_queues(struct net_device *dev) 155{ 156 struct macvlan_dev *vlan = netdev_priv(dev); 157 struct macvtap_queue *q; 158 159 spin_lock(&macvtap_lock); 160 q = rcu_dereference(vlan->tap); 161 if (!q) { 162 spin_unlock(&macvtap_lock); 163 return; 164 } 165 166 rcu_assign_pointer(vlan->tap, NULL); 167 rcu_assign_pointer(q->vlan, NULL); 168 spin_unlock(&macvtap_lock); 169 170 synchronize_rcu(); 171 sock_put(&q->sk); 172} 173 174/* 175 * Forward happens for data that gets sent from one macvlan 176 * endpoint to another one in bridge mode. We just take 177 * the skb and put it into the receive queue. 178 */ 179static int macvtap_forward(struct net_device *dev, struct sk_buff *skb) 180{ 181 struct macvtap_queue *q = macvtap_get_queue(dev, skb); 182 if (!q) 183 goto drop; 184 185 if (skb_queue_len(&q->sk.sk_receive_queue) >= dev->tx_queue_len) 186 goto drop; 187 188 skb_queue_tail(&q->sk.sk_receive_queue, skb); 189 wake_up_interruptible_poll(sk_sleep(&q->sk), POLLIN | POLLRDNORM | POLLRDBAND); 190 return NET_RX_SUCCESS; 191 192drop: 193 kfree_skb(skb); 194 return NET_RX_DROP; 195} 196 197/* 198 * Receive is for data from the external interface (lowerdev), 199 * in case of macvtap, we can treat that the same way as 200 * forward, which macvlan cannot. 201 */ 202static int macvtap_receive(struct sk_buff *skb) 203{ 204 skb_push(skb, ETH_HLEN); 205 return macvtap_forward(skb->dev, skb); 206} 207 208static int macvtap_newlink(struct net *src_net, 209 struct net_device *dev, 210 struct nlattr *tb[], 211 struct nlattr *data[]) 212{ 213 struct device *classdev; 214 dev_t devt; 215 int err; 216 217 err = macvlan_common_newlink(src_net, dev, tb, data, 218 macvtap_receive, macvtap_forward); 219 if (err) 220 goto out; 221 222 devt = MKDEV(MAJOR(macvtap_major), dev->ifindex); 223 224 classdev = device_create(macvtap_class, &dev->dev, devt, 225 dev, "tap%d", dev->ifindex); 226 if (IS_ERR(classdev)) { 227 err = PTR_ERR(classdev); 228 macvtap_del_queues(dev); 229 } 230 231out: 232 return err; 233} 234 235static void macvtap_dellink(struct net_device *dev, 236 struct list_head *head) 237{ 238 device_destroy(macvtap_class, 239 MKDEV(MAJOR(macvtap_major), dev->ifindex)); 240 241 macvtap_del_queues(dev); 242 macvlan_dellink(dev, head); 243} 244 245static void macvtap_setup(struct net_device *dev) 246{ 247 macvlan_common_setup(dev); 248 dev->tx_queue_len = TUN_READQ_SIZE; 249} 250 251static struct rtnl_link_ops macvtap_link_ops __read_mostly = { 252 .kind = "macvtap", 253 .setup = macvtap_setup, 254 .newlink = macvtap_newlink, 255 .dellink = macvtap_dellink, 256}; 257 258 259static void macvtap_sock_write_space(struct sock *sk) 260{ 261 wait_queue_head_t *wqueue; 262 263 if (!sock_writeable(sk) || 264 !test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags)) 265 return; 266 267 wqueue = sk_sleep(sk); 268 if (wqueue && waitqueue_active(wqueue)) 269 wake_up_interruptible_poll(wqueue, POLLOUT | POLLWRNORM | POLLWRBAND); 270} 271 272static int macvtap_open(struct inode *inode, struct file *file) 273{ 274 struct net *net = current->nsproxy->net_ns; 275 struct net_device *dev = dev_get_by_index(net, iminor(inode)); 276 struct macvtap_queue *q; 277 int err; 278 279 err = -ENODEV; 280 if (!dev) 281 goto out; 282 283 /* check if this is a macvtap device */ 284 err = -EINVAL; 285 if (dev->rtnl_link_ops != &macvtap_link_ops) 286 goto out; 287 288 err = -ENOMEM; 289 q = (struct macvtap_queue *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL, 290 &macvtap_proto); 291 if (!q) 292 goto out; 293 294 q->sock.wq = &q->wq; 295 init_waitqueue_head(&q->wq.wait); 296 q->sock.type = SOCK_RAW; 297 q->sock.state = SS_CONNECTED; 298 q->sock.file = file; 299 q->sock.ops = &macvtap_socket_ops; 300 sock_init_data(&q->sock, &q->sk); 301 q->sk.sk_write_space = macvtap_sock_write_space; 302 q->flags = IFF_VNET_HDR | IFF_NO_PI | IFF_TAP; 303 q->vnet_hdr_sz = sizeof(struct virtio_net_hdr); 304 305 err = macvtap_set_queue(dev, file, q); 306 if (err) 307 sock_put(&q->sk); 308 309out: 310 if (dev) 311 dev_put(dev); 312 313 return err; 314} 315 316static int macvtap_release(struct inode *inode, struct file *file) 317{ 318 struct macvtap_queue *q = file->private_data; 319 macvtap_put_queue(q); 320 return 0; 321} 322 323static unsigned int macvtap_poll(struct file *file, poll_table * wait) 324{ 325 struct macvtap_queue *q = file->private_data; 326 unsigned int mask = POLLERR; 327 328 if (!q) 329 goto out; 330 331 mask = 0; 332 poll_wait(file, &q->wq.wait, wait); 333 334 if (!skb_queue_empty(&q->sk.sk_receive_queue)) 335 mask |= POLLIN | POLLRDNORM; 336 337 if (sock_writeable(&q->sk) || 338 (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &q->sock.flags) && 339 sock_writeable(&q->sk))) 340 mask |= POLLOUT | POLLWRNORM; 341 342out: 343 return mask; 344} 345 346static inline struct sk_buff *macvtap_alloc_skb(struct sock *sk, size_t prepad, 347 size_t len, size_t linear, 348 int noblock, int *err) 349{ 350 struct sk_buff *skb; 351 352 /* Under a page? Don't bother with paged skb. */ 353 if (prepad + len < PAGE_SIZE || !linear) 354 linear = len; 355 356 skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock, 357 err); 358 if (!skb) 359 return NULL; 360 361 skb_reserve(skb, prepad); 362 skb_put(skb, linear); 363 skb->data_len = len - linear; 364 skb->len += len - linear; 365 366 return skb; 367} 368 369/* 370 * macvtap_skb_from_vnet_hdr and macvtap_skb_to_vnet_hdr should 371 * be shared with the tun/tap driver. 372 */ 373static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb, 374 struct virtio_net_hdr *vnet_hdr) 375{ 376 unsigned short gso_type = 0; 377 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) { 378 switch (vnet_hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) { 379 case VIRTIO_NET_HDR_GSO_TCPV4: 380 gso_type = SKB_GSO_TCPV4; 381 break; 382 case VIRTIO_NET_HDR_GSO_TCPV6: 383 gso_type = SKB_GSO_TCPV6; 384 break; 385 case VIRTIO_NET_HDR_GSO_UDP: 386 gso_type = SKB_GSO_UDP; 387 break; 388 default: 389 return -EINVAL; 390 } 391 392 if (vnet_hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN) 393 gso_type |= SKB_GSO_TCP_ECN; 394 395 if (vnet_hdr->gso_size == 0) 396 return -EINVAL; 397 } 398 399 if (vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { 400 if (!skb_partial_csum_set(skb, vnet_hdr->csum_start, 401 vnet_hdr->csum_offset)) 402 return -EINVAL; 403 } 404 405 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) { 406 skb_shinfo(skb)->gso_size = vnet_hdr->gso_size; 407 skb_shinfo(skb)->gso_type = gso_type; 408 409 /* Header must be checked, and gso_segs computed. */ 410 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY; 411 skb_shinfo(skb)->gso_segs = 0; 412 } 413 return 0; 414} 415 416static int macvtap_skb_to_vnet_hdr(const struct sk_buff *skb, 417 struct virtio_net_hdr *vnet_hdr) 418{ 419 memset(vnet_hdr, 0, sizeof(*vnet_hdr)); 420 421 if (skb_is_gso(skb)) { 422 struct skb_shared_info *sinfo = skb_shinfo(skb); 423 424 /* This is a hint as to how much should be linear. */ 425 vnet_hdr->hdr_len = skb_headlen(skb); 426 vnet_hdr->gso_size = sinfo->gso_size; 427 if (sinfo->gso_type & SKB_GSO_TCPV4) 428 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4; 429 else if (sinfo->gso_type & SKB_GSO_TCPV6) 430 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6; 431 else if (sinfo->gso_type & SKB_GSO_UDP) 432 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP; 433 else 434 BUG(); 435 if (sinfo->gso_type & SKB_GSO_TCP_ECN) 436 vnet_hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN; 437 } else 438 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE; 439 440 if (skb->ip_summed == CHECKSUM_PARTIAL) { 441 vnet_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; 442 vnet_hdr->csum_start = skb->csum_start - 443 skb_headroom(skb); 444 vnet_hdr->csum_offset = skb->csum_offset; 445 } /* else everything is zero */ 446 447 return 0; 448} 449 450 451/* Get packet from user space buffer */ 452static ssize_t macvtap_get_user(struct macvtap_queue *q, 453 const struct iovec *iv, size_t count, 454 int noblock) 455{ 456 struct sk_buff *skb; 457 struct macvlan_dev *vlan; 458 size_t len = count; 459 int err; 460 struct virtio_net_hdr vnet_hdr = { 0 }; 461 int vnet_hdr_len = 0; 462 463 if (q->flags & IFF_VNET_HDR) { 464 vnet_hdr_len = q->vnet_hdr_sz; 465 466 err = -EINVAL; 467 if ((len -= vnet_hdr_len) < 0) 468 goto err; 469 470 err = memcpy_fromiovecend((void *)&vnet_hdr, iv, 0, 471 sizeof(vnet_hdr)); 472 if (err < 0) 473 goto err; 474 if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && 475 vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 > 476 vnet_hdr.hdr_len) 477 vnet_hdr.hdr_len = vnet_hdr.csum_start + 478 vnet_hdr.csum_offset + 2; 479 err = -EINVAL; 480 if (vnet_hdr.hdr_len > len) 481 goto err; 482 } 483 484 err = -EINVAL; 485 if (unlikely(len < ETH_HLEN)) 486 goto err; 487 488 skb = macvtap_alloc_skb(&q->sk, NET_IP_ALIGN, len, vnet_hdr.hdr_len, 489 noblock, &err); 490 if (!skb) 491 goto err; 492 493 err = skb_copy_datagram_from_iovec(skb, 0, iv, vnet_hdr_len, len); 494 if (err) 495 goto err_kfree; 496 497 skb_set_network_header(skb, ETH_HLEN); 498 skb_reset_mac_header(skb); 499 skb->protocol = eth_hdr(skb)->h_proto; 500 501 if (vnet_hdr_len) { 502 err = macvtap_skb_from_vnet_hdr(skb, &vnet_hdr); 503 if (err) 504 goto err_kfree; 505 } 506 507 rcu_read_lock_bh(); 508 vlan = rcu_dereference(q->vlan); 509 if (vlan) 510 macvlan_start_xmit(skb, vlan->dev); 511 else 512 kfree_skb(skb); 513 rcu_read_unlock_bh(); 514 515 return count; 516 517err_kfree: 518 kfree_skb(skb); 519 520err: 521 rcu_read_lock_bh(); 522 vlan = rcu_dereference(q->vlan); 523 if (vlan) 524 netdev_get_tx_queue(vlan->dev, 0)->tx_dropped++; 525 rcu_read_unlock_bh(); 526 527 return err; 528} 529 530static ssize_t macvtap_aio_write(struct kiocb *iocb, const struct iovec *iv, 531 unsigned long count, loff_t pos) 532{ 533 struct file *file = iocb->ki_filp; 534 ssize_t result = -ENOLINK; 535 struct macvtap_queue *q = file->private_data; 536 537 result = macvtap_get_user(q, iv, iov_length(iv, count), 538 file->f_flags & O_NONBLOCK); 539 return result; 540} 541 542/* Put packet to the user space buffer */ 543static ssize_t macvtap_put_user(struct macvtap_queue *q, 544 const struct sk_buff *skb, 545 const struct iovec *iv, int len) 546{ 547 struct macvlan_dev *vlan; 548 int ret; 549 int vnet_hdr_len = 0; 550 551 if (q->flags & IFF_VNET_HDR) { 552 struct virtio_net_hdr vnet_hdr; 553 vnet_hdr_len = q->vnet_hdr_sz; 554 if ((len -= vnet_hdr_len) < 0) 555 return -EINVAL; 556 557 ret = macvtap_skb_to_vnet_hdr(skb, &vnet_hdr); 558 if (ret) 559 return ret; 560 561 if (memcpy_toiovecend(iv, (void *)&vnet_hdr, 0, sizeof(vnet_hdr))) 562 return -EFAULT; 563 } 564 565 len = min_t(int, skb->len, len); 566 567 ret = skb_copy_datagram_const_iovec(skb, 0, iv, vnet_hdr_len, len); 568 569 rcu_read_lock_bh(); 570 vlan = rcu_dereference(q->vlan); 571 if (vlan) 572 macvlan_count_rx(vlan, len, ret == 0, 0); 573 rcu_read_unlock_bh(); 574 575 return ret ? ret : (len + vnet_hdr_len); 576} 577 578static ssize_t macvtap_do_read(struct macvtap_queue *q, struct kiocb *iocb, 579 const struct iovec *iv, unsigned long len, 580 int noblock) 581{ 582 DECLARE_WAITQUEUE(wait, current); 583 struct sk_buff *skb; 584 ssize_t ret = 0; 585 586 add_wait_queue(sk_sleep(&q->sk), &wait); 587 while (len) { 588 current->state = TASK_INTERRUPTIBLE; 589 590 /* Read frames from the queue */ 591 skb = skb_dequeue(&q->sk.sk_receive_queue); 592 if (!skb) { 593 if (noblock) { 594 ret = -EAGAIN; 595 break; 596 } 597 if (signal_pending(current)) { 598 ret = -ERESTARTSYS; 599 break; 600 } 601 /* Nothing to read, let's sleep */ 602 schedule(); 603 continue; 604 } 605 ret = macvtap_put_user(q, skb, iv, len); 606 kfree_skb(skb); 607 break; 608 } 609 610 current->state = TASK_RUNNING; 611 remove_wait_queue(sk_sleep(&q->sk), &wait); 612 return ret; 613} 614 615static ssize_t macvtap_aio_read(struct kiocb *iocb, const struct iovec *iv, 616 unsigned long count, loff_t pos) 617{ 618 struct file *file = iocb->ki_filp; 619 struct macvtap_queue *q = file->private_data; 620 ssize_t len, ret = 0; 621 622 len = iov_length(iv, count); 623 if (len < 0) { 624 ret = -EINVAL; 625 goto out; 626 } 627 628 ret = macvtap_do_read(q, iocb, iv, len, file->f_flags & O_NONBLOCK); 629 ret = min_t(ssize_t, ret, len); 630out: 631 return ret; 632} 633 634/* 635 * provide compatibility with generic tun/tap interface 636 */ 637static long macvtap_ioctl(struct file *file, unsigned int cmd, 638 unsigned long arg) 639{ 640 struct macvtap_queue *q = file->private_data; 641 struct macvlan_dev *vlan; 642 void __user *argp = (void __user *)arg; 643 struct ifreq __user *ifr = argp; 644 unsigned int __user *up = argp; 645 unsigned int u; 646 int __user *sp = argp; 647 int s; 648 int ret; 649 650 switch (cmd) { 651 case TUNSETIFF: 652 /* ignore the name, just look at flags */ 653 if (get_user(u, &ifr->ifr_flags)) 654 return -EFAULT; 655 656 ret = 0; 657 if ((u & ~IFF_VNET_HDR) != (IFF_NO_PI | IFF_TAP)) 658 ret = -EINVAL; 659 else 660 q->flags = u; 661 662 return ret; 663 664 case TUNGETIFF: 665 rcu_read_lock_bh(); 666 vlan = rcu_dereference(q->vlan); 667 if (vlan) 668 dev_hold(vlan->dev); 669 rcu_read_unlock_bh(); 670 671 if (!vlan) 672 return -ENOLINK; 673 674 ret = 0; 675 if (copy_to_user(&ifr->ifr_name, q->vlan->dev->name, IFNAMSIZ) || 676 put_user(q->flags, &ifr->ifr_flags)) 677 ret = -EFAULT; 678 dev_put(vlan->dev); 679 return ret; 680 681 case TUNGETFEATURES: 682 if (put_user(IFF_TAP | IFF_NO_PI | IFF_VNET_HDR, up)) 683 return -EFAULT; 684 return 0; 685 686 case TUNSETSNDBUF: 687 if (get_user(u, up)) 688 return -EFAULT; 689 690 q->sk.sk_sndbuf = u; 691 return 0; 692 693 case TUNGETVNETHDRSZ: 694 s = q->vnet_hdr_sz; 695 if (put_user(s, sp)) 696 return -EFAULT; 697 return 0; 698 699 case TUNSETVNETHDRSZ: 700 if (get_user(s, sp)) 701 return -EFAULT; 702 if (s < (int)sizeof(struct virtio_net_hdr)) 703 return -EINVAL; 704 705 q->vnet_hdr_sz = s; 706 return 0; 707 708 case TUNSETOFFLOAD: 709 /* let the user check for future flags */ 710 if (arg & ~(TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6 | 711 TUN_F_TSO_ECN | TUN_F_UFO)) 712 return -EINVAL; 713 714 /* TODO: only accept frames with the features that 715 got enabled for forwarded frames */ 716 if (!(q->flags & IFF_VNET_HDR)) 717 return -EINVAL; 718 return 0; 719 720 default: 721 return -EINVAL; 722 } 723} 724 725#ifdef CONFIG_COMPAT 726static long macvtap_compat_ioctl(struct file *file, unsigned int cmd, 727 unsigned long arg) 728{ 729 return macvtap_ioctl(file, cmd, (unsigned long)compat_ptr(arg)); 730} 731#endif 732 733static const struct file_operations macvtap_fops = { 734 .owner = THIS_MODULE, 735 .open = macvtap_open, 736 .release = macvtap_release, 737 .aio_read = macvtap_aio_read, 738 .aio_write = macvtap_aio_write, 739 .poll = macvtap_poll, 740 .llseek = no_llseek, 741 .unlocked_ioctl = macvtap_ioctl, 742#ifdef CONFIG_COMPAT 743 .compat_ioctl = macvtap_compat_ioctl, 744#endif 745}; 746 747static int macvtap_sendmsg(struct kiocb *iocb, struct socket *sock, 748 struct msghdr *m, size_t total_len) 749{ 750 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock); 751 return macvtap_get_user(q, m->msg_iov, total_len, 752 m->msg_flags & MSG_DONTWAIT); 753} 754 755static int macvtap_recvmsg(struct kiocb *iocb, struct socket *sock, 756 struct msghdr *m, size_t total_len, 757 int flags) 758{ 759 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock); 760 int ret; 761 if (flags & ~(MSG_DONTWAIT|MSG_TRUNC)) 762 return -EINVAL; 763 ret = macvtap_do_read(q, iocb, m->msg_iov, total_len, 764 flags & MSG_DONTWAIT); 765 if (ret > total_len) { 766 m->msg_flags |= MSG_TRUNC; 767 ret = flags & MSG_TRUNC ? ret : total_len; 768 } 769 return ret; 770} 771 772/* Ops structure to mimic raw sockets with tun */ 773static const struct proto_ops macvtap_socket_ops = { 774 .sendmsg = macvtap_sendmsg, 775 .recvmsg = macvtap_recvmsg, 776}; 777 778/* Get an underlying socket object from tun file. Returns error unless file is 779 * attached to a device. The returned object works like a packet socket, it 780 * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for 781 * holding a reference to the file for as long as the socket is in use. */ 782struct socket *macvtap_get_socket(struct file *file) 783{ 784 struct macvtap_queue *q; 785 if (file->f_op != &macvtap_fops) 786 return ERR_PTR(-EINVAL); 787 q = file->private_data; 788 if (!q) 789 return ERR_PTR(-EBADFD); 790 return &q->sock; 791} 792EXPORT_SYMBOL_GPL(macvtap_get_socket); 793 794static int macvtap_init(void) 795{ 796 int err; 797 798 err = alloc_chrdev_region(&macvtap_major, 0, 799 MACVTAP_NUM_DEVS, "macvtap"); 800 if (err) 801 goto out1; 802 803 cdev_init(&macvtap_cdev, &macvtap_fops); 804 err = cdev_add(&macvtap_cdev, macvtap_major, MACVTAP_NUM_DEVS); 805 if (err) 806 goto out2; 807 808 macvtap_class = class_create(THIS_MODULE, "macvtap"); 809 if (IS_ERR(macvtap_class)) { 810 err = PTR_ERR(macvtap_class); 811 goto out3; 812 } 813 814 err = macvlan_link_register(&macvtap_link_ops); 815 if (err) 816 goto out4; 817 818 return 0; 819 820out4: 821 class_unregister(macvtap_class); 822out3: 823 cdev_del(&macvtap_cdev); 824out2: 825 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS); 826out1: 827 return err; 828} 829module_init(macvtap_init); 830 831static void macvtap_exit(void) 832{ 833 rtnl_link_unregister(&macvtap_link_ops); 834 class_unregister(macvtap_class); 835 cdev_del(&macvtap_cdev); 836 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS); 837} 838module_exit(macvtap_exit); 839 840MODULE_ALIAS_RTNL_LINK("macvtap"); 841MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>"); 842MODULE_LICENSE("GPL"); 843