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