blob: 6696e56e63206024c7f529331f7088c72406982d [file] [log] [blame]
Arnd Bergmann20d29d72010-01-30 12:24:26 +00001#include <linux/etherdevice.h>
2#include <linux/if_macvlan.h>
3#include <linux/interrupt.h>
4#include <linux/nsproxy.h>
5#include <linux/compat.h>
6#include <linux/if_tun.h>
7#include <linux/module.h>
8#include <linux/skbuff.h>
9#include <linux/cache.h>
10#include <linux/sched.h>
11#include <linux/types.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090012#include <linux/slab.h>
Arnd Bergmann20d29d72010-01-30 12:24:26 +000013#include <linux/init.h>
14#include <linux/wait.h>
15#include <linux/cdev.h>
16#include <linux/fs.h>
17
18#include <net/net_namespace.h>
19#include <net/rtnetlink.h>
20#include <net/sock.h>
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +000021#include <linux/virtio_net.h>
Arnd Bergmann20d29d72010-01-30 12:24:26 +000022
23/*
24 * A macvtap queue is the central object of this driver, it connects
25 * an open character device to a macvlan interface. There can be
26 * multiple queues on one interface, which map back to queues
27 * implemented in hardware on the underlying device.
28 *
29 * macvtap_proto is used to allocate queues through the sock allocation
30 * mechanism.
31 *
32 * TODO: multiqueue support is currently not implemented, even though
33 * macvtap is basically prepared for that. We will need to add this
34 * here as well as in virtio-net and qemu to get line rate on 10gbit
35 * adapters from a guest.
36 */
37struct macvtap_queue {
38 struct sock sk;
39 struct socket sock;
Eric Dumazet43815482010-04-29 11:01:49 +000040 struct socket_wq wq;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +030041 int vnet_hdr_sz;
Eric Dumazet13707f92011-01-26 19:28:23 +000042 struct macvlan_dev __rcu *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +000043 struct file *file;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +000044 unsigned int flags;
Arnd Bergmann20d29d72010-01-30 12:24:26 +000045};
46
47static struct proto macvtap_proto = {
48 .name = "macvtap",
49 .owner = THIS_MODULE,
50 .obj_size = sizeof (struct macvtap_queue),
51};
52
53/*
54 * Minor number matches netdev->ifindex, so need a potentially
55 * large value. This also makes it possible to split the
56 * tap functionality out again in the future by offering it
57 * from other drivers besides macvtap. As long as every device
58 * only has one tap, the interface numbers assure that the
59 * device nodes are unique.
60 */
David S. Miller1ebed712010-07-10 19:25:50 -070061static dev_t macvtap_major;
Arnd Bergmann20d29d72010-01-30 12:24:26 +000062#define MACVTAP_NUM_DEVS 65536
63static struct class *macvtap_class;
64static struct cdev macvtap_cdev;
65
Arnd Bergmann501c7742010-02-18 05:46:50 +000066static const struct proto_ops macvtap_socket_ops;
67
Arnd Bergmann20d29d72010-01-30 12:24:26 +000068/*
69 * RCU usage:
Arnd Bergmann02df55d2010-02-18 05:45:36 +000070 * The macvtap_queue and the macvlan_dev are loosely coupled, the
71 * pointers from one to the other can only be read while rcu_read_lock
72 * or macvtap_lock is held.
Arnd Bergmann20d29d72010-01-30 12:24:26 +000073 *
Arnd Bergmann02df55d2010-02-18 05:45:36 +000074 * Both the file and the macvlan_dev hold a reference on the macvtap_queue
75 * through sock_hold(&q->sk). When the macvlan_dev goes away first,
76 * q->vlan becomes inaccessible. When the files gets closed,
77 * macvtap_get_queue() fails.
Arnd Bergmann20d29d72010-01-30 12:24:26 +000078 *
Arnd Bergmann02df55d2010-02-18 05:45:36 +000079 * There may still be references to the struct sock inside of the
80 * queue from outbound SKBs, but these never reference back to the
81 * file or the dev. The data structure is freed through __sk_free
82 * when both our references and any pending SKBs are gone.
Arnd Bergmann20d29d72010-01-30 12:24:26 +000083 */
84static DEFINE_SPINLOCK(macvtap_lock);
85
86/*
Krishna Kumar1565c7c2010-08-04 06:15:59 +000087 * get_slot: return a [unused/occupied] slot in vlan->taps[]:
88 * - if 'q' is NULL, return the first empty slot;
89 * - otherwise, return the slot this pointer occupies.
Arnd Bergmann20d29d72010-01-30 12:24:26 +000090 */
Krishna Kumar1565c7c2010-08-04 06:15:59 +000091static int get_slot(struct macvlan_dev *vlan, struct macvtap_queue *q)
92{
93 int i;
94
95 for (i = 0; i < MAX_MACVTAP_QUEUES; i++) {
96 if (rcu_dereference(vlan->taps[i]) == q)
97 return i;
98 }
99
100 /* Should never happen */
101 BUG_ON(1);
102}
103
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000104static int macvtap_set_queue(struct net_device *dev, struct file *file,
105 struct macvtap_queue *q)
106{
107 struct macvlan_dev *vlan = netdev_priv(dev);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000108 int index;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000109 int err = -EBUSY;
110
111 spin_lock(&macvtap_lock);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000112 if (vlan->numvtaps == MAX_MACVTAP_QUEUES)
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000113 goto out;
114
115 err = 0;
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000116 index = get_slot(vlan, NULL);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000117 rcu_assign_pointer(q->vlan, vlan);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000118 rcu_assign_pointer(vlan->taps[index], q);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000119 sock_hold(&q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000120
121 q->file = file;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000122 file->private_data = q;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000123
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000124 vlan->numvtaps++;
125
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000126out:
127 spin_unlock(&macvtap_lock);
128 return err;
129}
130
131/*
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000132 * The file owning the queue got closed, give up both
133 * the reference that the files holds as well as the
134 * one from the macvlan_dev if that still exists.
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000135 *
136 * Using the spinlock makes sure that we don't get
137 * to the queue again after destroying it.
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000138 */
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000139static void macvtap_put_queue(struct macvtap_queue *q)
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000140{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000141 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000142
143 spin_lock(&macvtap_lock);
Eric Dumazet13707f92011-01-26 19:28:23 +0000144 vlan = rcu_dereference_protected(q->vlan,
145 lockdep_is_held(&macvtap_lock));
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000146 if (vlan) {
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000147 int index = get_slot(vlan, q);
148
149 rcu_assign_pointer(vlan->taps[index], NULL);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000150 rcu_assign_pointer(q->vlan, NULL);
151 sock_put(&q->sk);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000152 --vlan->numvtaps;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000153 }
154
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000155 spin_unlock(&macvtap_lock);
156
157 synchronize_rcu();
158 sock_put(&q->sk);
159}
160
161/*
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000162 * Select a queue based on the rxq of the device on which this packet
163 * arrived. If the incoming device is not mq, calculate a flow hash
164 * to select a queue. If all fails, find the first available queue.
165 * Cache vlan->numvtaps since it can become zero during the execution
166 * of this function.
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000167 */
168static struct macvtap_queue *macvtap_get_queue(struct net_device *dev,
169 struct sk_buff *skb)
170{
171 struct macvlan_dev *vlan = netdev_priv(dev);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000172 struct macvtap_queue *tap = NULL;
173 int numvtaps = vlan->numvtaps;
174 __u32 rxq;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000175
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000176 if (!numvtaps)
177 goto out;
178
179 if (likely(skb_rx_queue_recorded(skb))) {
180 rxq = skb_get_rx_queue(skb);
181
182 while (unlikely(rxq >= numvtaps))
183 rxq -= numvtaps;
184
185 tap = rcu_dereference(vlan->taps[rxq]);
186 if (tap)
187 goto out;
188 }
189
190 /* Check if we can use flow to select a queue */
191 rxq = skb_get_rxhash(skb);
192 if (rxq) {
193 tap = rcu_dereference(vlan->taps[rxq % numvtaps]);
194 if (tap)
195 goto out;
196 }
197
198 /* Everything failed - find first available queue */
199 for (rxq = 0; rxq < MAX_MACVTAP_QUEUES; rxq++) {
200 tap = rcu_dereference(vlan->taps[rxq]);
201 if (tap)
202 break;
203 }
204
205out:
206 return tap;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000207}
208
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000209/*
210 * The net_device is going away, give up the reference
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000211 * that it holds on all queues and safely set the pointer
212 * from the queues to NULL.
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000213 */
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000214static void macvtap_del_queues(struct net_device *dev)
215{
216 struct macvlan_dev *vlan = netdev_priv(dev);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000217 struct macvtap_queue *q, *qlist[MAX_MACVTAP_QUEUES];
218 int i, j = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000219
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000220 /* macvtap_put_queue can free some slots, so go through all slots */
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000221 spin_lock(&macvtap_lock);
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000222 for (i = 0; i < MAX_MACVTAP_QUEUES && vlan->numvtaps; i++) {
Eric Dumazet13707f92011-01-26 19:28:23 +0000223 q = rcu_dereference_protected(vlan->taps[i],
224 lockdep_is_held(&macvtap_lock));
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000225 if (q) {
226 qlist[j++] = q;
227 rcu_assign_pointer(vlan->taps[i], NULL);
228 rcu_assign_pointer(q->vlan, NULL);
229 vlan->numvtaps--;
230 }
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000231 }
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000232 BUG_ON(vlan->numvtaps != 0);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000233 spin_unlock(&macvtap_lock);
234
235 synchronize_rcu();
Krishna Kumar1565c7c2010-08-04 06:15:59 +0000236
237 for (--j; j >= 0; j--)
238 sock_put(&qlist[j]->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000239}
240
241/*
242 * Forward happens for data that gets sent from one macvlan
243 * endpoint to another one in bridge mode. We just take
244 * the skb and put it into the receive queue.
245 */
246static int macvtap_forward(struct net_device *dev, struct sk_buff *skb)
247{
248 struct macvtap_queue *q = macvtap_get_queue(dev, skb);
249 if (!q)
Herbert Xu8a357472010-07-21 21:44:31 +0000250 goto drop;
251
252 if (skb_queue_len(&q->sk.sk_receive_queue) >= dev->tx_queue_len)
253 goto drop;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000254
255 skb_queue_tail(&q->sk.sk_receive_queue, skb);
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000256 wake_up_interruptible_poll(sk_sleep(&q->sk), POLLIN | POLLRDNORM | POLLRDBAND);
Herbert Xu8a357472010-07-21 21:44:31 +0000257 return NET_RX_SUCCESS;
258
259drop:
260 kfree_skb(skb);
261 return NET_RX_DROP;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000262}
263
264/*
265 * Receive is for data from the external interface (lowerdev),
266 * in case of macvtap, we can treat that the same way as
267 * forward, which macvlan cannot.
268 */
269static int macvtap_receive(struct sk_buff *skb)
270{
271 skb_push(skb, ETH_HLEN);
272 return macvtap_forward(skb->dev, skb);
273}
274
275static int macvtap_newlink(struct net *src_net,
276 struct net_device *dev,
277 struct nlattr *tb[],
278 struct nlattr *data[])
279{
280 struct device *classdev;
281 dev_t devt;
282 int err;
283
284 err = macvlan_common_newlink(src_net, dev, tb, data,
285 macvtap_receive, macvtap_forward);
286 if (err)
287 goto out;
288
289 devt = MKDEV(MAJOR(macvtap_major), dev->ifindex);
290
291 classdev = device_create(macvtap_class, &dev->dev, devt,
292 dev, "tap%d", dev->ifindex);
293 if (IS_ERR(classdev)) {
294 err = PTR_ERR(classdev);
295 macvtap_del_queues(dev);
296 }
297
298out:
299 return err;
300}
301
302static void macvtap_dellink(struct net_device *dev,
303 struct list_head *head)
304{
305 device_destroy(macvtap_class,
306 MKDEV(MAJOR(macvtap_major), dev->ifindex));
307
308 macvtap_del_queues(dev);
309 macvlan_dellink(dev, head);
310}
311
Herbert Xu8a357472010-07-21 21:44:31 +0000312static void macvtap_setup(struct net_device *dev)
313{
314 macvlan_common_setup(dev);
315 dev->tx_queue_len = TUN_READQ_SIZE;
316}
317
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000318static struct rtnl_link_ops macvtap_link_ops __read_mostly = {
319 .kind = "macvtap",
Herbert Xu8a357472010-07-21 21:44:31 +0000320 .setup = macvtap_setup,
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000321 .newlink = macvtap_newlink,
322 .dellink = macvtap_dellink,
323};
324
325
326static void macvtap_sock_write_space(struct sock *sk)
327{
Eric Dumazet43815482010-04-29 11:01:49 +0000328 wait_queue_head_t *wqueue;
329
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000330 if (!sock_writeable(sk) ||
331 !test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags))
332 return;
333
Eric Dumazet43815482010-04-29 11:01:49 +0000334 wqueue = sk_sleep(sk);
335 if (wqueue && waitqueue_active(wqueue))
336 wake_up_interruptible_poll(wqueue, POLLOUT | POLLWRNORM | POLLWRBAND);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000337}
338
339static int macvtap_open(struct inode *inode, struct file *file)
340{
341 struct net *net = current->nsproxy->net_ns;
342 struct net_device *dev = dev_get_by_index(net, iminor(inode));
343 struct macvtap_queue *q;
344 int err;
345
346 err = -ENODEV;
347 if (!dev)
348 goto out;
349
350 /* check if this is a macvtap device */
351 err = -EINVAL;
352 if (dev->rtnl_link_ops != &macvtap_link_ops)
353 goto out;
354
355 err = -ENOMEM;
356 q = (struct macvtap_queue *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL,
357 &macvtap_proto);
358 if (!q)
359 goto out;
360
Eric Dumazet43815482010-04-29 11:01:49 +0000361 q->sock.wq = &q->wq;
362 init_waitqueue_head(&q->wq.wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000363 q->sock.type = SOCK_RAW;
364 q->sock.state = SS_CONNECTED;
Arnd Bergmann501c7742010-02-18 05:46:50 +0000365 q->sock.file = file;
366 q->sock.ops = &macvtap_socket_ops;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000367 sock_init_data(&q->sock, &q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000368 q->sk.sk_write_space = macvtap_sock_write_space;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000369 q->flags = IFF_VNET_HDR | IFF_NO_PI | IFF_TAP;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300370 q->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000371
372 err = macvtap_set_queue(dev, file, q);
373 if (err)
374 sock_put(&q->sk);
375
376out:
377 if (dev)
378 dev_put(dev);
379
380 return err;
381}
382
383static int macvtap_release(struct inode *inode, struct file *file)
384{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000385 struct macvtap_queue *q = file->private_data;
386 macvtap_put_queue(q);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000387 return 0;
388}
389
390static unsigned int macvtap_poll(struct file *file, poll_table * wait)
391{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000392 struct macvtap_queue *q = file->private_data;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000393 unsigned int mask = POLLERR;
394
395 if (!q)
396 goto out;
397
398 mask = 0;
Eric Dumazet43815482010-04-29 11:01:49 +0000399 poll_wait(file, &q->wq.wait, wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000400
401 if (!skb_queue_empty(&q->sk.sk_receive_queue))
402 mask |= POLLIN | POLLRDNORM;
403
404 if (sock_writeable(&q->sk) ||
405 (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &q->sock.flags) &&
406 sock_writeable(&q->sk)))
407 mask |= POLLOUT | POLLWRNORM;
408
409out:
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000410 return mask;
411}
412
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000413static inline struct sk_buff *macvtap_alloc_skb(struct sock *sk, size_t prepad,
414 size_t len, size_t linear,
415 int noblock, int *err)
416{
417 struct sk_buff *skb;
418
419 /* Under a page? Don't bother with paged skb. */
420 if (prepad + len < PAGE_SIZE || !linear)
421 linear = len;
422
423 skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
424 err);
425 if (!skb)
426 return NULL;
427
428 skb_reserve(skb, prepad);
429 skb_put(skb, linear);
430 skb->data_len = len - linear;
431 skb->len += len - linear;
432
433 return skb;
434}
435
436/*
437 * macvtap_skb_from_vnet_hdr and macvtap_skb_to_vnet_hdr should
438 * be shared with the tun/tap driver.
439 */
440static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb,
441 struct virtio_net_hdr *vnet_hdr)
442{
443 unsigned short gso_type = 0;
444 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
445 switch (vnet_hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
446 case VIRTIO_NET_HDR_GSO_TCPV4:
447 gso_type = SKB_GSO_TCPV4;
448 break;
449 case VIRTIO_NET_HDR_GSO_TCPV6:
450 gso_type = SKB_GSO_TCPV6;
451 break;
452 case VIRTIO_NET_HDR_GSO_UDP:
453 gso_type = SKB_GSO_UDP;
454 break;
455 default:
456 return -EINVAL;
457 }
458
459 if (vnet_hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
460 gso_type |= SKB_GSO_TCP_ECN;
461
462 if (vnet_hdr->gso_size == 0)
463 return -EINVAL;
464 }
465
466 if (vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
467 if (!skb_partial_csum_set(skb, vnet_hdr->csum_start,
468 vnet_hdr->csum_offset))
469 return -EINVAL;
470 }
471
472 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
473 skb_shinfo(skb)->gso_size = vnet_hdr->gso_size;
474 skb_shinfo(skb)->gso_type = gso_type;
475
476 /* Header must be checked, and gso_segs computed. */
477 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
478 skb_shinfo(skb)->gso_segs = 0;
479 }
480 return 0;
481}
482
483static int macvtap_skb_to_vnet_hdr(const struct sk_buff *skb,
484 struct virtio_net_hdr *vnet_hdr)
485{
486 memset(vnet_hdr, 0, sizeof(*vnet_hdr));
487
488 if (skb_is_gso(skb)) {
489 struct skb_shared_info *sinfo = skb_shinfo(skb);
490
491 /* This is a hint as to how much should be linear. */
492 vnet_hdr->hdr_len = skb_headlen(skb);
493 vnet_hdr->gso_size = sinfo->gso_size;
494 if (sinfo->gso_type & SKB_GSO_TCPV4)
495 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
496 else if (sinfo->gso_type & SKB_GSO_TCPV6)
497 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
498 else if (sinfo->gso_type & SKB_GSO_UDP)
499 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP;
500 else
501 BUG();
502 if (sinfo->gso_type & SKB_GSO_TCP_ECN)
503 vnet_hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
504 } else
505 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
506
507 if (skb->ip_summed == CHECKSUM_PARTIAL) {
508 vnet_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
Michał Mirosław55508d62010-12-14 15:24:08 +0000509 vnet_hdr->csum_start = skb_checksum_start_offset(skb);
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000510 vnet_hdr->csum_offset = skb->csum_offset;
511 } /* else everything is zero */
512
513 return 0;
514}
515
516
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000517/* Get packet from user space buffer */
518static ssize_t macvtap_get_user(struct macvtap_queue *q,
519 const struct iovec *iv, size_t count,
520 int noblock)
521{
522 struct sk_buff *skb;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000523 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000524 size_t len = count;
525 int err;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000526 struct virtio_net_hdr vnet_hdr = { 0 };
527 int vnet_hdr_len = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000528
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000529 if (q->flags & IFF_VNET_HDR) {
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300530 vnet_hdr_len = q->vnet_hdr_sz;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000531
532 err = -EINVAL;
Nicolas Kaiserce3c8692011-03-04 13:49:41 +0000533 if (len < vnet_hdr_len)
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000534 goto err;
Nicolas Kaiserce3c8692011-03-04 13:49:41 +0000535 len -= vnet_hdr_len;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000536
537 err = memcpy_fromiovecend((void *)&vnet_hdr, iv, 0,
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300538 sizeof(vnet_hdr));
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000539 if (err < 0)
540 goto err;
541 if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
542 vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 >
543 vnet_hdr.hdr_len)
544 vnet_hdr.hdr_len = vnet_hdr.csum_start +
545 vnet_hdr.csum_offset + 2;
546 err = -EINVAL;
547 if (vnet_hdr.hdr_len > len)
548 goto err;
549 }
550
551 err = -EINVAL;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000552 if (unlikely(len < ETH_HLEN))
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000553 goto err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000554
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000555 skb = macvtap_alloc_skb(&q->sk, NET_IP_ALIGN, len, vnet_hdr.hdr_len,
556 noblock, &err);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000557 if (!skb)
558 goto err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000559
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000560 err = skb_copy_datagram_from_iovec(skb, 0, iv, vnet_hdr_len, len);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000561 if (err)
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000562 goto err_kfree;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000563
564 skb_set_network_header(skb, ETH_HLEN);
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000565 skb_reset_mac_header(skb);
566 skb->protocol = eth_hdr(skb)->h_proto;
567
568 if (vnet_hdr_len) {
569 err = macvtap_skb_from_vnet_hdr(skb, &vnet_hdr);
570 if (err)
571 goto err_kfree;
572 }
573
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000574 rcu_read_lock_bh();
Eric Dumazet13707f92011-01-26 19:28:23 +0000575 vlan = rcu_dereference_bh(q->vlan);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000576 if (vlan)
577 macvlan_start_xmit(skb, vlan->dev);
578 else
579 kfree_skb(skb);
580 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000581
582 return count;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000583
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000584err_kfree:
585 kfree_skb(skb);
586
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000587err:
588 rcu_read_lock_bh();
Eric Dumazet13707f92011-01-26 19:28:23 +0000589 vlan = rcu_dereference_bh(q->vlan);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000590 if (vlan)
Eric Dumazet1ac9ad12011-01-12 12:13:14 +0000591 vlan->dev->stats.tx_dropped++;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000592 rcu_read_unlock_bh();
593
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000594 return err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000595}
596
597static ssize_t macvtap_aio_write(struct kiocb *iocb, const struct iovec *iv,
598 unsigned long count, loff_t pos)
599{
600 struct file *file = iocb->ki_filp;
601 ssize_t result = -ENOLINK;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000602 struct macvtap_queue *q = file->private_data;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000603
604 result = macvtap_get_user(q, iv, iov_length(iv, count),
605 file->f_flags & O_NONBLOCK);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000606 return result;
607}
608
609/* Put packet to the user space buffer */
610static ssize_t macvtap_put_user(struct macvtap_queue *q,
611 const struct sk_buff *skb,
612 const struct iovec *iv, int len)
613{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000614 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000615 int ret;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000616 int vnet_hdr_len = 0;
617
618 if (q->flags & IFF_VNET_HDR) {
619 struct virtio_net_hdr vnet_hdr;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300620 vnet_hdr_len = q->vnet_hdr_sz;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000621 if ((len -= vnet_hdr_len) < 0)
622 return -EINVAL;
623
624 ret = macvtap_skb_to_vnet_hdr(skb, &vnet_hdr);
625 if (ret)
626 return ret;
627
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300628 if (memcpy_toiovecend(iv, (void *)&vnet_hdr, 0, sizeof(vnet_hdr)))
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000629 return -EFAULT;
630 }
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000631
632 len = min_t(int, skb->len, len);
633
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000634 ret = skb_copy_datagram_const_iovec(skb, 0, iv, vnet_hdr_len, len);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000635
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000636 rcu_read_lock_bh();
Eric Dumazet13707f92011-01-26 19:28:23 +0000637 vlan = rcu_dereference_bh(q->vlan);
Arnd Bergmann501c7742010-02-18 05:46:50 +0000638 if (vlan)
639 macvlan_count_rx(vlan, len, ret == 0, 0);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000640 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000641
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000642 return ret ? ret : (len + vnet_hdr_len);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000643}
644
Arnd Bergmann501c7742010-02-18 05:46:50 +0000645static ssize_t macvtap_do_read(struct macvtap_queue *q, struct kiocb *iocb,
646 const struct iovec *iv, unsigned long len,
647 int noblock)
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000648{
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000649 DECLARE_WAITQUEUE(wait, current);
650 struct sk_buff *skb;
Arnd Bergmann501c7742010-02-18 05:46:50 +0000651 ssize_t ret = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000652
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000653 add_wait_queue(sk_sleep(&q->sk), &wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000654 while (len) {
655 current->state = TASK_INTERRUPTIBLE;
656
657 /* Read frames from the queue */
658 skb = skb_dequeue(&q->sk.sk_receive_queue);
659 if (!skb) {
Arnd Bergmann501c7742010-02-18 05:46:50 +0000660 if (noblock) {
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000661 ret = -EAGAIN;
662 break;
663 }
664 if (signal_pending(current)) {
665 ret = -ERESTARTSYS;
666 break;
667 }
668 /* Nothing to read, let's sleep */
669 schedule();
670 continue;
671 }
672 ret = macvtap_put_user(q, skb, iv, len);
673 kfree_skb(skb);
674 break;
675 }
676
677 current->state = TASK_RUNNING;
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000678 remove_wait_queue(sk_sleep(&q->sk), &wait);
Arnd Bergmann501c7742010-02-18 05:46:50 +0000679 return ret;
680}
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000681
Arnd Bergmann501c7742010-02-18 05:46:50 +0000682static ssize_t macvtap_aio_read(struct kiocb *iocb, const struct iovec *iv,
683 unsigned long count, loff_t pos)
684{
685 struct file *file = iocb->ki_filp;
686 struct macvtap_queue *q = file->private_data;
687 ssize_t len, ret = 0;
688
689 len = iov_length(iv, count);
690 if (len < 0) {
691 ret = -EINVAL;
692 goto out;
693 }
694
695 ret = macvtap_do_read(q, iocb, iv, len, file->f_flags & O_NONBLOCK);
696 ret = min_t(ssize_t, ret, len); /* XXX copied from tun.c. Why? */
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000697out:
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000698 return ret;
699}
700
701/*
702 * provide compatibility with generic tun/tap interface
703 */
704static long macvtap_ioctl(struct file *file, unsigned int cmd,
705 unsigned long arg)
706{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000707 struct macvtap_queue *q = file->private_data;
708 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000709 void __user *argp = (void __user *)arg;
710 struct ifreq __user *ifr = argp;
711 unsigned int __user *up = argp;
712 unsigned int u;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300713 int __user *sp = argp;
714 int s;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000715 int ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000716
717 switch (cmd) {
718 case TUNSETIFF:
719 /* ignore the name, just look at flags */
720 if (get_user(u, &ifr->ifr_flags))
721 return -EFAULT;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000722
723 ret = 0;
724 if ((u & ~IFF_VNET_HDR) != (IFF_NO_PI | IFF_TAP))
725 ret = -EINVAL;
726 else
727 q->flags = u;
728
729 return ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000730
731 case TUNGETIFF:
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000732 rcu_read_lock_bh();
Eric Dumazet13707f92011-01-26 19:28:23 +0000733 vlan = rcu_dereference_bh(q->vlan);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000734 if (vlan)
735 dev_hold(vlan->dev);
736 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000737
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000738 if (!vlan)
739 return -ENOLINK;
740
741 ret = 0;
Eric Dumazet13707f92011-01-26 19:28:23 +0000742 if (copy_to_user(&ifr->ifr_name, vlan->dev->name, IFNAMSIZ) ||
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000743 put_user(q->flags, &ifr->ifr_flags))
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000744 ret = -EFAULT;
745 dev_put(vlan->dev);
746 return ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000747
748 case TUNGETFEATURES:
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000749 if (put_user(IFF_TAP | IFF_NO_PI | IFF_VNET_HDR, up))
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000750 return -EFAULT;
751 return 0;
752
753 case TUNSETSNDBUF:
754 if (get_user(u, up))
755 return -EFAULT;
756
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000757 q->sk.sk_sndbuf = u;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000758 return 0;
759
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300760 case TUNGETVNETHDRSZ:
761 s = q->vnet_hdr_sz;
762 if (put_user(s, sp))
763 return -EFAULT;
764 return 0;
765
766 case TUNSETVNETHDRSZ:
767 if (get_user(s, sp))
768 return -EFAULT;
769 if (s < (int)sizeof(struct virtio_net_hdr))
770 return -EINVAL;
771
772 q->vnet_hdr_sz = s;
773 return 0;
774
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000775 case TUNSETOFFLOAD:
776 /* let the user check for future flags */
777 if (arg & ~(TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6 |
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000778 TUN_F_TSO_ECN | TUN_F_UFO))
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000779 return -EINVAL;
780
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000781 /* TODO: only accept frames with the features that
782 got enabled for forwarded frames */
783 if (!(q->flags & IFF_VNET_HDR))
784 return -EINVAL;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000785 return 0;
786
787 default:
788 return -EINVAL;
789 }
790}
791
792#ifdef CONFIG_COMPAT
793static long macvtap_compat_ioctl(struct file *file, unsigned int cmd,
794 unsigned long arg)
795{
796 return macvtap_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
797}
798#endif
799
800static const struct file_operations macvtap_fops = {
801 .owner = THIS_MODULE,
802 .open = macvtap_open,
803 .release = macvtap_release,
804 .aio_read = macvtap_aio_read,
805 .aio_write = macvtap_aio_write,
806 .poll = macvtap_poll,
807 .llseek = no_llseek,
808 .unlocked_ioctl = macvtap_ioctl,
809#ifdef CONFIG_COMPAT
810 .compat_ioctl = macvtap_compat_ioctl,
811#endif
812};
813
Arnd Bergmann501c7742010-02-18 05:46:50 +0000814static int macvtap_sendmsg(struct kiocb *iocb, struct socket *sock,
815 struct msghdr *m, size_t total_len)
816{
817 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock);
818 return macvtap_get_user(q, m->msg_iov, total_len,
819 m->msg_flags & MSG_DONTWAIT);
820}
821
822static int macvtap_recvmsg(struct kiocb *iocb, struct socket *sock,
823 struct msghdr *m, size_t total_len,
824 int flags)
825{
826 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock);
827 int ret;
828 if (flags & ~(MSG_DONTWAIT|MSG_TRUNC))
829 return -EINVAL;
830 ret = macvtap_do_read(q, iocb, m->msg_iov, total_len,
831 flags & MSG_DONTWAIT);
832 if (ret > total_len) {
833 m->msg_flags |= MSG_TRUNC;
834 ret = flags & MSG_TRUNC ? ret : total_len;
835 }
836 return ret;
837}
838
839/* Ops structure to mimic raw sockets with tun */
840static const struct proto_ops macvtap_socket_ops = {
841 .sendmsg = macvtap_sendmsg,
842 .recvmsg = macvtap_recvmsg,
843};
844
845/* Get an underlying socket object from tun file. Returns error unless file is
846 * attached to a device. The returned object works like a packet socket, it
847 * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for
848 * holding a reference to the file for as long as the socket is in use. */
849struct socket *macvtap_get_socket(struct file *file)
850{
851 struct macvtap_queue *q;
852 if (file->f_op != &macvtap_fops)
853 return ERR_PTR(-EINVAL);
854 q = file->private_data;
855 if (!q)
856 return ERR_PTR(-EBADFD);
857 return &q->sock;
858}
859EXPORT_SYMBOL_GPL(macvtap_get_socket);
860
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000861static int macvtap_init(void)
862{
863 int err;
864
865 err = alloc_chrdev_region(&macvtap_major, 0,
866 MACVTAP_NUM_DEVS, "macvtap");
867 if (err)
868 goto out1;
869
870 cdev_init(&macvtap_cdev, &macvtap_fops);
871 err = cdev_add(&macvtap_cdev, macvtap_major, MACVTAP_NUM_DEVS);
872 if (err)
873 goto out2;
874
875 macvtap_class = class_create(THIS_MODULE, "macvtap");
876 if (IS_ERR(macvtap_class)) {
877 err = PTR_ERR(macvtap_class);
878 goto out3;
879 }
880
881 err = macvlan_link_register(&macvtap_link_ops);
882 if (err)
883 goto out4;
884
885 return 0;
886
887out4:
888 class_unregister(macvtap_class);
889out3:
890 cdev_del(&macvtap_cdev);
891out2:
892 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS);
893out1:
894 return err;
895}
896module_init(macvtap_init);
897
898static void macvtap_exit(void)
899{
900 rtnl_link_unregister(&macvtap_link_ops);
901 class_unregister(macvtap_class);
902 cdev_del(&macvtap_cdev);
903 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS);
904}
905module_exit(macvtap_exit);
906
907MODULE_ALIAS_RTNL_LINK("macvtap");
908MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
909MODULE_LICENSE("GPL");