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