2 * TUN - Universal TUN/TAP device driver.
3 * Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com>
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.
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.
15 * $Id: tun.c,v 1.15 2002/03/01 02:44:24 maxk Exp $
21 * Brian Braunstein <linuxkernel@bristyle.com> 2007/03/23
22 * Fixed hw address handling. Now net_device.dev_addr is kept consistent
23 * with tun.dev_addr when the address is set by this module.
25 * Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14
26 * Add TUNSETLINK ioctl to set the link encapsulation
28 * Mark Smith <markzzzsmith@yahoo.com.au>
29 * Use random_ether_addr() for tap MAC address.
31 * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20
32 * Fixes in packet dropping, queue length setting and queue wakeup.
33 * Increased default tx queue length.
37 * Daniel Podlejski <underley@underley.eu.org>
38 * Modifications for 2.3.99-pre5 kernel.
41 #define DRV_NAME "tun"
42 #define DRV_VERSION "1.6"
43 #define DRV_DESCRIPTION "Universal TUN/TAP device driver"
44 #define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>"
46 #include <linux/module.h>
47 #include <linux/errno.h>
48 #include <linux/kernel.h>
49 #include <linux/major.h>
50 #include <linux/slab.h>
51 #include <linux/poll.h>
52 #include <linux/fcntl.h>
53 #include <linux/init.h>
54 #include <linux/skbuff.h>
55 #include <linux/netdevice.h>
56 #include <linux/etherdevice.h>
57 #include <linux/miscdevice.h>
58 #include <linux/ethtool.h>
59 #include <linux/rtnetlink.h>
61 #include <linux/if_arp.h>
62 #include <linux/if_ether.h>
63 #include <linux/if_tun.h>
64 #include <linux/crc32.h>
65 #include <net/net_namespace.h>
67 #include <asm/system.h>
68 #include <asm/uaccess.h>
74 /* Network device part of the driver */
76 static LIST_HEAD(tun_dev_list
);
77 static const struct ethtool_ops tun_ethtool_ops
;
79 /* Net device open. */
80 static int tun_net_open(struct net_device
*dev
)
82 netif_start_queue(dev
);
86 /* Net device close. */
87 static int tun_net_close(struct net_device
*dev
)
89 netif_stop_queue(dev
);
93 /* Net device start xmit */
94 static int tun_net_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
96 struct tun_struct
*tun
= netdev_priv(dev
);
98 DBG(KERN_INFO
"%s: tun_net_xmit %d\n", tun
->dev
->name
, skb
->len
);
100 /* Drop packet if interface is not attached */
104 /* Packet dropping */
105 if (skb_queue_len(&tun
->readq
) >= dev
->tx_queue_len
) {
106 if (!(tun
->flags
& TUN_ONE_QUEUE
)) {
107 /* Normal queueing mode. */
108 /* Packet scheduler handles dropping of further packets. */
109 netif_stop_queue(dev
);
111 /* We won't see all dropped packets individually, so overrun
112 * error is more appropriate. */
113 tun
->stats
.tx_fifo_errors
++;
115 /* Single queue mode.
116 * Driver handles dropping of all packets itself. */
122 skb_queue_tail(&tun
->readq
, skb
);
123 dev
->trans_start
= jiffies
;
125 /* Notify and wake up reader process */
126 if (tun
->flags
& TUN_FASYNC
)
127 kill_fasync(&tun
->fasync
, SIGIO
, POLL_IN
);
128 wake_up_interruptible(&tun
->read_wait
);
132 tun
->stats
.tx_dropped
++;
137 /** Add the specified Ethernet address to this multicast filter. */
139 add_multi(u32
* filter
, const u8
* addr
)
141 int bit_nr
= ether_crc(ETH_ALEN
, addr
) >> 26;
142 filter
[bit_nr
>> 5] |= 1 << (bit_nr
& 31);
145 /** Remove the specified Ethernet addres from this multicast filter. */
147 del_multi(u32
* filter
, const u8
* addr
)
149 int bit_nr
= ether_crc(ETH_ALEN
, addr
) >> 26;
150 filter
[bit_nr
>> 5] &= ~(1 << (bit_nr
& 31));
153 /** Update the list of multicast groups to which the network device belongs.
154 * This list is used to filter packets being sent from the character device to
155 * the network device. */
157 tun_net_mclist(struct net_device
*dev
)
159 struct tun_struct
*tun
= netdev_priv(dev
);
160 const struct dev_mc_list
*mclist
;
162 DBG(KERN_DEBUG
"%s: tun_net_mclist: mc_count %d\n",
163 dev
->name
, dev
->mc_count
);
164 memset(tun
->chr_filter
, 0, sizeof tun
->chr_filter
);
165 for (i
= 0, mclist
= dev
->mc_list
; i
< dev
->mc_count
&& mclist
!= NULL
;
166 i
++, mclist
= mclist
->next
) {
167 add_multi(tun
->net_filter
, mclist
->dmi_addr
);
168 DBG(KERN_DEBUG
"%s: tun_net_mclist: %x:%x:%x:%x:%x:%x\n",
170 mclist
->dmi_addr
[0], mclist
->dmi_addr
[1], mclist
->dmi_addr
[2],
171 mclist
->dmi_addr
[3], mclist
->dmi_addr
[4], mclist
->dmi_addr
[5]);
175 static struct net_device_stats
*tun_net_stats(struct net_device
*dev
)
177 struct tun_struct
*tun
= netdev_priv(dev
);
181 /* Initialize net device. */
182 static void tun_net_init(struct net_device
*dev
)
184 struct tun_struct
*tun
= netdev_priv(dev
);
186 switch (tun
->flags
& TUN_TYPE_MASK
) {
188 /* Point-to-Point TUN Device */
189 dev
->hard_header_len
= 0;
193 /* Zero header length */
194 dev
->type
= ARPHRD_NONE
;
195 dev
->flags
= IFF_POINTOPOINT
| IFF_NOARP
| IFF_MULTICAST
;
196 dev
->tx_queue_len
= TUN_READQ_SIZE
; /* We prefer our own queue length */
200 /* Ethernet TAP Device */
201 dev
->set_multicast_list
= tun_net_mclist
;
205 /* random address already created for us by tun_set_iff, use it */
206 memcpy(dev
->dev_addr
, tun
->dev_addr
, min(sizeof(tun
->dev_addr
), sizeof(dev
->dev_addr
)) );
208 dev
->tx_queue_len
= TUN_READQ_SIZE
; /* We prefer our own queue length */
213 /* Character device part */
216 static unsigned int tun_chr_poll(struct file
*file
, poll_table
* wait
)
218 struct tun_struct
*tun
= file
->private_data
;
219 unsigned int mask
= POLLOUT
| POLLWRNORM
;
224 DBG(KERN_INFO
"%s: tun_chr_poll\n", tun
->dev
->name
);
226 poll_wait(file
, &tun
->read_wait
, wait
);
228 if (!skb_queue_empty(&tun
->readq
))
229 mask
|= POLLIN
| POLLRDNORM
;
234 /* Get packet from user space buffer */
235 static __inline__ ssize_t
tun_get_user(struct tun_struct
*tun
, struct iovec
*iv
, size_t count
)
237 struct tun_pi pi
= { 0, __constant_htons(ETH_P_IP
) };
239 size_t len
= count
, align
= 0;
241 if (!(tun
->flags
& TUN_NO_PI
)) {
242 if ((len
-= sizeof(pi
)) > count
)
245 if(memcpy_fromiovec((void *)&pi
, iv
, sizeof(pi
)))
249 if ((tun
->flags
& TUN_TYPE_MASK
) == TUN_TAP_DEV
)
250 align
= NET_IP_ALIGN
;
252 if (!(skb
= alloc_skb(len
+ align
, GFP_KERNEL
))) {
253 tun
->stats
.rx_dropped
++;
258 skb_reserve(skb
, align
);
259 if (memcpy_fromiovec(skb_put(skb
, len
), iv
, len
)) {
260 tun
->stats
.rx_dropped
++;
265 switch (tun
->flags
& TUN_TYPE_MASK
) {
267 skb_reset_mac_header(skb
);
268 skb
->protocol
= pi
.proto
;
272 skb
->protocol
= eth_type_trans(skb
, tun
->dev
);
276 if (tun
->flags
& TUN_NOCHECKSUM
)
277 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
280 tun
->dev
->last_rx
= jiffies
;
282 tun
->stats
.rx_packets
++;
283 tun
->stats
.rx_bytes
+= len
;
288 static inline size_t iov_total(const struct iovec
*iv
, unsigned long count
)
293 for (i
= 0, len
= 0; i
< count
; i
++)
294 len
+= iv
[i
].iov_len
;
299 static ssize_t
tun_chr_aio_write(struct kiocb
*iocb
, const struct iovec
*iv
,
300 unsigned long count
, loff_t pos
)
302 struct tun_struct
*tun
= iocb
->ki_filp
->private_data
;
307 DBG(KERN_INFO
"%s: tun_chr_write %ld\n", tun
->dev
->name
, count
);
309 return tun_get_user(tun
, (struct iovec
*) iv
, iov_total(iv
, count
));
312 /* Put packet to the user space buffer */
313 static __inline__ ssize_t
tun_put_user(struct tun_struct
*tun
,
315 struct iovec
*iv
, int len
)
317 struct tun_pi pi
= { 0, skb
->protocol
};
320 if (!(tun
->flags
& TUN_NO_PI
)) {
321 if ((len
-= sizeof(pi
)) < 0)
324 if (len
< skb
->len
) {
325 /* Packet will be striped */
326 pi
.flags
|= TUN_PKT_STRIP
;
329 if (memcpy_toiovec(iv
, (void *) &pi
, sizeof(pi
)))
334 len
= min_t(int, skb
->len
, len
);
336 skb_copy_datagram_iovec(skb
, 0, iv
, len
);
339 tun
->stats
.tx_packets
++;
340 tun
->stats
.tx_bytes
+= len
;
345 static ssize_t
tun_chr_aio_read(struct kiocb
*iocb
, const struct iovec
*iv
,
346 unsigned long count
, loff_t pos
)
348 struct file
*file
= iocb
->ki_filp
;
349 struct tun_struct
*tun
= file
->private_data
;
350 DECLARE_WAITQUEUE(wait
, current
);
352 ssize_t len
, ret
= 0;
357 DBG(KERN_INFO
"%s: tun_chr_read\n", tun
->dev
->name
);
359 len
= iov_total(iv
, count
);
363 add_wait_queue(&tun
->read_wait
, &wait
);
365 const u8 ones
[ ETH_ALEN
] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
369 current
->state
= TASK_INTERRUPTIBLE
;
371 /* Read frames from the queue */
372 if (!(skb
=skb_dequeue(&tun
->readq
))) {
373 if (file
->f_flags
& O_NONBLOCK
) {
377 if (signal_pending(current
)) {
382 /* Nothing to read, let's sleep */
386 netif_wake_queue(tun
->dev
);
388 /** Decide whether to accept this packet. This code is designed to
389 * behave identically to an Ethernet interface. Accept the packet if
390 * - we are promiscuous.
391 * - the packet is addressed to us.
392 * - the packet is broadcast.
393 * - the packet is multicast and
394 * - we are multicast promiscous.
395 * - we belong to the multicast group.
397 skb_copy_from_linear_data(skb
, addr
, min_t(size_t, sizeof addr
,
399 bit_nr
= ether_crc(sizeof addr
, addr
) >> 26;
400 if ((tun
->if_flags
& IFF_PROMISC
) ||
401 memcmp(addr
, tun
->dev_addr
, sizeof addr
) == 0 ||
402 memcmp(addr
, ones
, sizeof addr
) == 0 ||
403 (((addr
[0] == 1 && addr
[1] == 0 && addr
[2] == 0x5e) ||
404 (addr
[0] == 0x33 && addr
[1] == 0x33)) &&
405 ((tun
->if_flags
& IFF_ALLMULTI
) ||
406 (tun
->chr_filter
[bit_nr
>> 5] & (1 << (bit_nr
& 31)))))) {
407 DBG(KERN_DEBUG
"%s: tun_chr_readv: accepted: %x:%x:%x:%x:%x:%x\n",
408 tun
->dev
->name
, addr
[0], addr
[1], addr
[2],
409 addr
[3], addr
[4], addr
[5]);
410 ret
= tun_put_user(tun
, skb
, (struct iovec
*) iv
, len
);
414 DBG(KERN_DEBUG
"%s: tun_chr_readv: rejected: %x:%x:%x:%x:%x:%x\n",
415 tun
->dev
->name
, addr
[0], addr
[1], addr
[2],
416 addr
[3], addr
[4], addr
[5]);
422 current
->state
= TASK_RUNNING
;
423 remove_wait_queue(&tun
->read_wait
, &wait
);
428 static void tun_setup(struct net_device
*dev
)
430 struct tun_struct
*tun
= netdev_priv(dev
);
432 skb_queue_head_init(&tun
->readq
);
433 init_waitqueue_head(&tun
->read_wait
);
438 SET_MODULE_OWNER(dev
);
439 dev
->open
= tun_net_open
;
440 dev
->hard_start_xmit
= tun_net_xmit
;
441 dev
->stop
= tun_net_close
;
442 dev
->get_stats
= tun_net_stats
;
443 dev
->ethtool_ops
= &tun_ethtool_ops
;
444 dev
->destructor
= free_netdev
;
447 static struct tun_struct
*tun_get_by_name(const char *name
)
449 struct tun_struct
*tun
;
452 list_for_each_entry(tun
, &tun_dev_list
, list
) {
453 if (!strncmp(tun
->dev
->name
, name
, IFNAMSIZ
))
460 static int tun_set_iff(struct file
*file
, struct ifreq
*ifr
)
462 struct tun_struct
*tun
;
463 struct net_device
*dev
;
466 tun
= tun_get_by_name(ifr
->ifr_name
);
471 /* Check permissions */
472 if (((tun
->owner
!= -1 &&
473 current
->euid
!= tun
->owner
) ||
475 current
->egid
!= tun
->group
)) &&
476 !capable(CAP_NET_ADMIN
))
479 else if (__dev_get_by_name(&init_net
, ifr
->ifr_name
))
483 unsigned long flags
= 0;
487 if (!capable(CAP_NET_ADMIN
))
491 if (ifr
->ifr_flags
& IFF_TUN
) {
493 flags
|= TUN_TUN_DEV
;
495 } else if (ifr
->ifr_flags
& IFF_TAP
) {
497 flags
|= TUN_TAP_DEV
;
503 name
= ifr
->ifr_name
;
505 dev
= alloc_netdev(sizeof(struct tun_struct
), name
,
510 tun
= netdev_priv(dev
);
513 /* Be promiscuous by default to maintain previous behaviour. */
514 tun
->if_flags
= IFF_PROMISC
;
515 /* Generate random Ethernet address. */
516 *(u16
*)tun
->dev_addr
= htons(0x00FF);
517 get_random_bytes(tun
->dev_addr
+ sizeof(u16
), 4);
518 memset(tun
->chr_filter
, 0, sizeof tun
->chr_filter
);
522 if (strchr(dev
->name
, '%')) {
523 err
= dev_alloc_name(dev
, dev
->name
);
528 err
= register_netdevice(tun
->dev
);
532 list_add(&tun
->list
, &tun_dev_list
);
535 DBG(KERN_INFO
"%s: tun_set_iff\n", tun
->dev
->name
);
537 if (ifr
->ifr_flags
& IFF_NO_PI
)
538 tun
->flags
|= TUN_NO_PI
;
540 if (ifr
->ifr_flags
& IFF_ONE_QUEUE
)
541 tun
->flags
|= TUN_ONE_QUEUE
;
543 file
->private_data
= tun
;
546 strcpy(ifr
->ifr_name
, tun
->dev
->name
);
555 static int tun_chr_ioctl(struct inode
*inode
, struct file
*file
,
556 unsigned int cmd
, unsigned long arg
)
558 struct tun_struct
*tun
= file
->private_data
;
559 void __user
* argp
= (void __user
*)arg
;
562 if (cmd
== TUNSETIFF
|| _IOC_TYPE(cmd
) == 0x89)
563 if (copy_from_user(&ifr
, argp
, sizeof ifr
))
566 if (cmd
== TUNSETIFF
&& !tun
) {
569 ifr
.ifr_name
[IFNAMSIZ
-1] = '\0';
572 err
= tun_set_iff(file
, &ifr
);
578 if (copy_to_user(argp
, &ifr
, sizeof(ifr
)))
586 DBG(KERN_INFO
"%s: tun_chr_ioctl cmd %d\n", tun
->dev
->name
, cmd
);
590 /* Disable/Enable checksum */
592 tun
->flags
|= TUN_NOCHECKSUM
;
594 tun
->flags
&= ~TUN_NOCHECKSUM
;
596 DBG(KERN_INFO
"%s: checksum %s\n",
597 tun
->dev
->name
, arg
? "disabled" : "enabled");
601 /* Disable/Enable persist mode */
603 tun
->flags
|= TUN_PERSIST
;
605 tun
->flags
&= ~TUN_PERSIST
;
607 DBG(KERN_INFO
"%s: persist %s\n",
608 tun
->dev
->name
, arg
? "disabled" : "enabled");
612 /* Set owner of the device */
613 tun
->owner
= (uid_t
) arg
;
615 DBG(KERN_INFO
"%s: owner set to %d\n", tun
->dev
->name
, tun
->owner
);
619 /* Set group of the device */
620 tun
->group
= (gid_t
) arg
;
622 DBG(KERN_INFO
"%s: group set to %d\n", tun
->dev
->name
, tun
->group
);
626 /* Only allow setting the type when the interface is down */
627 if (tun
->dev
->flags
& IFF_UP
) {
628 DBG(KERN_INFO
"%s: Linktype set failed because interface is up\n",
632 tun
->dev
->type
= (int) arg
;
633 DBG(KERN_INFO
"%s: linktype set to %d\n", tun
->dev
->name
, tun
->dev
->type
);
644 ifr
.ifr_flags
= tun
->if_flags
;
645 if (copy_to_user( argp
, &ifr
, sizeof ifr
))
650 /** Set the character device's interface flags. Currently only
651 * IFF_PROMISC and IFF_ALLMULTI are used. */
652 tun
->if_flags
= ifr
.ifr_flags
;
653 DBG(KERN_INFO
"%s: interface flags 0x%lx\n",
654 tun
->dev
->name
, tun
->if_flags
);
658 /* Note: the actual net device's address may be different */
659 memcpy(ifr
.ifr_hwaddr
.sa_data
, tun
->dev_addr
,
660 min(sizeof ifr
.ifr_hwaddr
.sa_data
, sizeof tun
->dev_addr
));
661 if (copy_to_user( argp
, &ifr
, sizeof ifr
))
667 /* try to set the actual net device's hw address */
668 int ret
= dev_set_mac_address(tun
->dev
, &ifr
.ifr_hwaddr
);
671 /** Set the character device's hardware address. This is used when
672 * filtering packets being sent from the network device to the character
674 memcpy(tun
->dev_addr
, ifr
.ifr_hwaddr
.sa_data
,
675 min(sizeof ifr
.ifr_hwaddr
.sa_data
, sizeof tun
->dev_addr
));
676 DBG(KERN_DEBUG
"%s: set hardware address: %x:%x:%x:%x:%x:%x\n",
678 tun
->dev_addr
[0], tun
->dev_addr
[1], tun
->dev_addr
[2],
679 tun
->dev_addr
[3], tun
->dev_addr
[4], tun
->dev_addr
[5]);
686 /** Add the specified group to the character device's multicast filter
688 add_multi(tun
->chr_filter
, ifr
.ifr_hwaddr
.sa_data
);
689 DBG(KERN_DEBUG
"%s: add multi: %x:%x:%x:%x:%x:%x\n",
691 (u8
)ifr
.ifr_hwaddr
.sa_data
[0], (u8
)ifr
.ifr_hwaddr
.sa_data
[1],
692 (u8
)ifr
.ifr_hwaddr
.sa_data
[2], (u8
)ifr
.ifr_hwaddr
.sa_data
[3],
693 (u8
)ifr
.ifr_hwaddr
.sa_data
[4], (u8
)ifr
.ifr_hwaddr
.sa_data
[5]);
697 /** Remove the specified group from the character device's multicast
699 del_multi(tun
->chr_filter
, ifr
.ifr_hwaddr
.sa_data
);
700 DBG(KERN_DEBUG
"%s: del multi: %x:%x:%x:%x:%x:%x\n",
702 (u8
)ifr
.ifr_hwaddr
.sa_data
[0], (u8
)ifr
.ifr_hwaddr
.sa_data
[1],
703 (u8
)ifr
.ifr_hwaddr
.sa_data
[2], (u8
)ifr
.ifr_hwaddr
.sa_data
[3],
704 (u8
)ifr
.ifr_hwaddr
.sa_data
[4], (u8
)ifr
.ifr_hwaddr
.sa_data
[5]);
714 static int tun_chr_fasync(int fd
, struct file
*file
, int on
)
716 struct tun_struct
*tun
= file
->private_data
;
722 DBG(KERN_INFO
"%s: tun_chr_fasync %d\n", tun
->dev
->name
, on
);
724 if ((ret
= fasync_helper(fd
, file
, on
, &tun
->fasync
)) < 0)
728 ret
= __f_setown(file
, task_pid(current
), PIDTYPE_PID
, 0);
731 tun
->flags
|= TUN_FASYNC
;
733 tun
->flags
&= ~TUN_FASYNC
;
738 static int tun_chr_open(struct inode
*inode
, struct file
* file
)
740 DBG1(KERN_INFO
"tunX: tun_chr_open\n");
741 file
->private_data
= NULL
;
745 static int tun_chr_close(struct inode
*inode
, struct file
*file
)
747 struct tun_struct
*tun
= file
->private_data
;
752 DBG(KERN_INFO
"%s: tun_chr_close\n", tun
->dev
->name
);
754 tun_chr_fasync(-1, file
, 0);
758 /* Detach from net device */
759 file
->private_data
= NULL
;
762 /* Drop read queue */
763 skb_queue_purge(&tun
->readq
);
765 if (!(tun
->flags
& TUN_PERSIST
)) {
766 list_del(&tun
->list
);
767 unregister_netdevice(tun
->dev
);
775 static const struct file_operations tun_fops
= {
776 .owner
= THIS_MODULE
,
778 .read
= do_sync_read
,
779 .aio_read
= tun_chr_aio_read
,
780 .write
= do_sync_write
,
781 .aio_write
= tun_chr_aio_write
,
782 .poll
= tun_chr_poll
,
783 .ioctl
= tun_chr_ioctl
,
784 .open
= tun_chr_open
,
785 .release
= tun_chr_close
,
786 .fasync
= tun_chr_fasync
789 static struct miscdevice tun_miscdev
= {
795 /* ethtool interface */
797 static int tun_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
800 cmd
->advertising
= 0;
801 cmd
->speed
= SPEED_10
;
802 cmd
->duplex
= DUPLEX_FULL
;
804 cmd
->phy_address
= 0;
805 cmd
->transceiver
= XCVR_INTERNAL
;
806 cmd
->autoneg
= AUTONEG_DISABLE
;
812 static void tun_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
814 struct tun_struct
*tun
= netdev_priv(dev
);
816 strcpy(info
->driver
, DRV_NAME
);
817 strcpy(info
->version
, DRV_VERSION
);
818 strcpy(info
->fw_version
, "N/A");
820 switch (tun
->flags
& TUN_TYPE_MASK
) {
822 strcpy(info
->bus_info
, "tun");
825 strcpy(info
->bus_info
, "tap");
830 static u32
tun_get_msglevel(struct net_device
*dev
)
833 struct tun_struct
*tun
= netdev_priv(dev
);
840 static void tun_set_msglevel(struct net_device
*dev
, u32 value
)
843 struct tun_struct
*tun
= netdev_priv(dev
);
848 static u32
tun_get_link(struct net_device
*dev
)
850 struct tun_struct
*tun
= netdev_priv(dev
);
851 return tun
->attached
;
854 static u32
tun_get_rx_csum(struct net_device
*dev
)
856 struct tun_struct
*tun
= netdev_priv(dev
);
857 return (tun
->flags
& TUN_NOCHECKSUM
) == 0;
860 static int tun_set_rx_csum(struct net_device
*dev
, u32 data
)
862 struct tun_struct
*tun
= netdev_priv(dev
);
864 tun
->flags
&= ~TUN_NOCHECKSUM
;
866 tun
->flags
|= TUN_NOCHECKSUM
;
870 static const struct ethtool_ops tun_ethtool_ops
= {
871 .get_settings
= tun_get_settings
,
872 .get_drvinfo
= tun_get_drvinfo
,
873 .get_msglevel
= tun_get_msglevel
,
874 .set_msglevel
= tun_set_msglevel
,
875 .get_link
= tun_get_link
,
876 .get_rx_csum
= tun_get_rx_csum
,
877 .set_rx_csum
= tun_set_rx_csum
880 static int __init
tun_init(void)
884 printk(KERN_INFO
"tun: %s, %s\n", DRV_DESCRIPTION
, DRV_VERSION
);
885 printk(KERN_INFO
"tun: %s\n", DRV_COPYRIGHT
);
887 ret
= misc_register(&tun_miscdev
);
889 printk(KERN_ERR
"tun: Can't register misc device %d\n", TUN_MINOR
);
893 static void tun_cleanup(void)
895 struct tun_struct
*tun
, *nxt
;
897 misc_deregister(&tun_miscdev
);
900 list_for_each_entry_safe(tun
, nxt
, &tun_dev_list
, list
) {
901 DBG(KERN_INFO
"%s cleaned up\n", tun
->dev
->name
);
902 unregister_netdevice(tun
->dev
);
908 module_init(tun_init
);
909 module_exit(tun_cleanup
);
910 MODULE_DESCRIPTION(DRV_DESCRIPTION
);
911 MODULE_AUTHOR(DRV_COPYRIGHT
);
912 MODULE_LICENSE("GPL");
913 MODULE_ALIAS_MISCDEV(TUN_MINOR
);