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