blob: 3b1c54a9c6ef12bc255f0af833ef6de2788da219 [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;
Arnd Bergmann20d29d72010-01-30 12:24:26 +000042 struct macvlan_dev *vlan;
43 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/*
87 * Choose the next free queue, for now there is only one
88 */
89static int macvtap_set_queue(struct net_device *dev, struct file *file,
90 struct macvtap_queue *q)
91{
92 struct macvlan_dev *vlan = netdev_priv(dev);
93 int err = -EBUSY;
94
95 spin_lock(&macvtap_lock);
96 if (rcu_dereference(vlan->tap))
97 goto out;
98
99 err = 0;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000100 rcu_assign_pointer(q->vlan, vlan);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000101 rcu_assign_pointer(vlan->tap, q);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000102 sock_hold(&q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000103
104 q->file = file;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000105 file->private_data = q;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000106
107out:
108 spin_unlock(&macvtap_lock);
109 return err;
110}
111
112/*
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000113 * The file owning the queue got closed, give up both
114 * the reference that the files holds as well as the
115 * one from the macvlan_dev if that still exists.
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000116 *
117 * Using the spinlock makes sure that we don't get
118 * to the queue again after destroying it.
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000119 */
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000120static void macvtap_put_queue(struct macvtap_queue *q)
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000121{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000122 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000123
124 spin_lock(&macvtap_lock);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000125 vlan = rcu_dereference(q->vlan);
126 if (vlan) {
127 rcu_assign_pointer(vlan->tap, NULL);
128 rcu_assign_pointer(q->vlan, NULL);
129 sock_put(&q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000130 }
131
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000132 spin_unlock(&macvtap_lock);
133
134 synchronize_rcu();
135 sock_put(&q->sk);
136}
137
138/*
139 * Since we only support one queue, just dereference the pointer.
140 */
141static struct macvtap_queue *macvtap_get_queue(struct net_device *dev,
142 struct sk_buff *skb)
143{
144 struct macvlan_dev *vlan = netdev_priv(dev);
145
146 return rcu_dereference(vlan->tap);
147}
148
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000149/*
150 * The net_device is going away, give up the reference
151 * that it holds on the queue (all the queues one day)
152 * and safely set the pointer from the queues to NULL.
153 */
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000154static void macvtap_del_queues(struct net_device *dev)
155{
156 struct macvlan_dev *vlan = netdev_priv(dev);
Arnd Bergmann564517e2010-02-11 05:55:39 +0000157 struct macvtap_queue *q;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000158
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000159 spin_lock(&macvtap_lock);
160 q = rcu_dereference(vlan->tap);
161 if (!q) {
162 spin_unlock(&macvtap_lock);
163 return;
164 }
165
166 rcu_assign_pointer(vlan->tap, NULL);
167 rcu_assign_pointer(q->vlan, NULL);
168 spin_unlock(&macvtap_lock);
169
170 synchronize_rcu();
Arnd Bergmann564517e2010-02-11 05:55:39 +0000171 sock_put(&q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000172}
173
174/*
175 * Forward happens for data that gets sent from one macvlan
176 * endpoint to another one in bridge mode. We just take
177 * the skb and put it into the receive queue.
178 */
179static int macvtap_forward(struct net_device *dev, struct sk_buff *skb)
180{
181 struct macvtap_queue *q = macvtap_get_queue(dev, skb);
182 if (!q)
Herbert Xu8a357472010-07-21 21:44:31 +0000183 goto drop;
184
185 if (skb_queue_len(&q->sk.sk_receive_queue) >= dev->tx_queue_len)
186 goto drop;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000187
188 skb_queue_tail(&q->sk.sk_receive_queue, skb);
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000189 wake_up_interruptible_poll(sk_sleep(&q->sk), POLLIN | POLLRDNORM | POLLRDBAND);
Herbert Xu8a357472010-07-21 21:44:31 +0000190 return NET_RX_SUCCESS;
191
192drop:
193 kfree_skb(skb);
194 return NET_RX_DROP;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000195}
196
197/*
198 * Receive is for data from the external interface (lowerdev),
199 * in case of macvtap, we can treat that the same way as
200 * forward, which macvlan cannot.
201 */
202static int macvtap_receive(struct sk_buff *skb)
203{
204 skb_push(skb, ETH_HLEN);
205 return macvtap_forward(skb->dev, skb);
206}
207
208static int macvtap_newlink(struct net *src_net,
209 struct net_device *dev,
210 struct nlattr *tb[],
211 struct nlattr *data[])
212{
213 struct device *classdev;
214 dev_t devt;
215 int err;
216
217 err = macvlan_common_newlink(src_net, dev, tb, data,
218 macvtap_receive, macvtap_forward);
219 if (err)
220 goto out;
221
222 devt = MKDEV(MAJOR(macvtap_major), dev->ifindex);
223
224 classdev = device_create(macvtap_class, &dev->dev, devt,
225 dev, "tap%d", dev->ifindex);
226 if (IS_ERR(classdev)) {
227 err = PTR_ERR(classdev);
228 macvtap_del_queues(dev);
229 }
230
231out:
232 return err;
233}
234
235static void macvtap_dellink(struct net_device *dev,
236 struct list_head *head)
237{
238 device_destroy(macvtap_class,
239 MKDEV(MAJOR(macvtap_major), dev->ifindex));
240
241 macvtap_del_queues(dev);
242 macvlan_dellink(dev, head);
243}
244
Herbert Xu8a357472010-07-21 21:44:31 +0000245static void macvtap_setup(struct net_device *dev)
246{
247 macvlan_common_setup(dev);
248 dev->tx_queue_len = TUN_READQ_SIZE;
249}
250
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000251static struct rtnl_link_ops macvtap_link_ops __read_mostly = {
252 .kind = "macvtap",
Herbert Xu8a357472010-07-21 21:44:31 +0000253 .setup = macvtap_setup,
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000254 .newlink = macvtap_newlink,
255 .dellink = macvtap_dellink,
256};
257
258
259static void macvtap_sock_write_space(struct sock *sk)
260{
Eric Dumazet43815482010-04-29 11:01:49 +0000261 wait_queue_head_t *wqueue;
262
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000263 if (!sock_writeable(sk) ||
264 !test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags))
265 return;
266
Eric Dumazet43815482010-04-29 11:01:49 +0000267 wqueue = sk_sleep(sk);
268 if (wqueue && waitqueue_active(wqueue))
269 wake_up_interruptible_poll(wqueue, POLLOUT | POLLWRNORM | POLLWRBAND);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000270}
271
272static int macvtap_open(struct inode *inode, struct file *file)
273{
274 struct net *net = current->nsproxy->net_ns;
275 struct net_device *dev = dev_get_by_index(net, iminor(inode));
276 struct macvtap_queue *q;
277 int err;
278
279 err = -ENODEV;
280 if (!dev)
281 goto out;
282
283 /* check if this is a macvtap device */
284 err = -EINVAL;
285 if (dev->rtnl_link_ops != &macvtap_link_ops)
286 goto out;
287
288 err = -ENOMEM;
289 q = (struct macvtap_queue *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL,
290 &macvtap_proto);
291 if (!q)
292 goto out;
293
Eric Dumazet43815482010-04-29 11:01:49 +0000294 q->sock.wq = &q->wq;
295 init_waitqueue_head(&q->wq.wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000296 q->sock.type = SOCK_RAW;
297 q->sock.state = SS_CONNECTED;
Arnd Bergmann501c7742010-02-18 05:46:50 +0000298 q->sock.file = file;
299 q->sock.ops = &macvtap_socket_ops;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000300 sock_init_data(&q->sock, &q->sk);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000301 q->sk.sk_write_space = macvtap_sock_write_space;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000302 q->flags = IFF_VNET_HDR | IFF_NO_PI | IFF_TAP;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300303 q->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000304
305 err = macvtap_set_queue(dev, file, q);
306 if (err)
307 sock_put(&q->sk);
308
309out:
310 if (dev)
311 dev_put(dev);
312
313 return err;
314}
315
316static int macvtap_release(struct inode *inode, struct file *file)
317{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000318 struct macvtap_queue *q = file->private_data;
319 macvtap_put_queue(q);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000320 return 0;
321}
322
323static unsigned int macvtap_poll(struct file *file, poll_table * wait)
324{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000325 struct macvtap_queue *q = file->private_data;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000326 unsigned int mask = POLLERR;
327
328 if (!q)
329 goto out;
330
331 mask = 0;
Eric Dumazet43815482010-04-29 11:01:49 +0000332 poll_wait(file, &q->wq.wait, wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000333
334 if (!skb_queue_empty(&q->sk.sk_receive_queue))
335 mask |= POLLIN | POLLRDNORM;
336
337 if (sock_writeable(&q->sk) ||
338 (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &q->sock.flags) &&
339 sock_writeable(&q->sk)))
340 mask |= POLLOUT | POLLWRNORM;
341
342out:
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000343 return mask;
344}
345
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000346static inline struct sk_buff *macvtap_alloc_skb(struct sock *sk, size_t prepad,
347 size_t len, size_t linear,
348 int noblock, int *err)
349{
350 struct sk_buff *skb;
351
352 /* Under a page? Don't bother with paged skb. */
353 if (prepad + len < PAGE_SIZE || !linear)
354 linear = len;
355
356 skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
357 err);
358 if (!skb)
359 return NULL;
360
361 skb_reserve(skb, prepad);
362 skb_put(skb, linear);
363 skb->data_len = len - linear;
364 skb->len += len - linear;
365
366 return skb;
367}
368
369/*
370 * macvtap_skb_from_vnet_hdr and macvtap_skb_to_vnet_hdr should
371 * be shared with the tun/tap driver.
372 */
373static int macvtap_skb_from_vnet_hdr(struct sk_buff *skb,
374 struct virtio_net_hdr *vnet_hdr)
375{
376 unsigned short gso_type = 0;
377 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
378 switch (vnet_hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
379 case VIRTIO_NET_HDR_GSO_TCPV4:
380 gso_type = SKB_GSO_TCPV4;
381 break;
382 case VIRTIO_NET_HDR_GSO_TCPV6:
383 gso_type = SKB_GSO_TCPV6;
384 break;
385 case VIRTIO_NET_HDR_GSO_UDP:
386 gso_type = SKB_GSO_UDP;
387 break;
388 default:
389 return -EINVAL;
390 }
391
392 if (vnet_hdr->gso_type & VIRTIO_NET_HDR_GSO_ECN)
393 gso_type |= SKB_GSO_TCP_ECN;
394
395 if (vnet_hdr->gso_size == 0)
396 return -EINVAL;
397 }
398
399 if (vnet_hdr->flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
400 if (!skb_partial_csum_set(skb, vnet_hdr->csum_start,
401 vnet_hdr->csum_offset))
402 return -EINVAL;
403 }
404
405 if (vnet_hdr->gso_type != VIRTIO_NET_HDR_GSO_NONE) {
406 skb_shinfo(skb)->gso_size = vnet_hdr->gso_size;
407 skb_shinfo(skb)->gso_type = gso_type;
408
409 /* Header must be checked, and gso_segs computed. */
410 skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
411 skb_shinfo(skb)->gso_segs = 0;
412 }
413 return 0;
414}
415
416static int macvtap_skb_to_vnet_hdr(const struct sk_buff *skb,
417 struct virtio_net_hdr *vnet_hdr)
418{
419 memset(vnet_hdr, 0, sizeof(*vnet_hdr));
420
421 if (skb_is_gso(skb)) {
422 struct skb_shared_info *sinfo = skb_shinfo(skb);
423
424 /* This is a hint as to how much should be linear. */
425 vnet_hdr->hdr_len = skb_headlen(skb);
426 vnet_hdr->gso_size = sinfo->gso_size;
427 if (sinfo->gso_type & SKB_GSO_TCPV4)
428 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
429 else if (sinfo->gso_type & SKB_GSO_TCPV6)
430 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
431 else if (sinfo->gso_type & SKB_GSO_UDP)
432 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_UDP;
433 else
434 BUG();
435 if (sinfo->gso_type & SKB_GSO_TCP_ECN)
436 vnet_hdr->gso_type |= VIRTIO_NET_HDR_GSO_ECN;
437 } else
438 vnet_hdr->gso_type = VIRTIO_NET_HDR_GSO_NONE;
439
440 if (skb->ip_summed == CHECKSUM_PARTIAL) {
441 vnet_hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
442 vnet_hdr->csum_start = skb->csum_start -
443 skb_headroom(skb);
444 vnet_hdr->csum_offset = skb->csum_offset;
445 } /* else everything is zero */
446
447 return 0;
448}
449
450
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000451/* Get packet from user space buffer */
452static ssize_t macvtap_get_user(struct macvtap_queue *q,
453 const struct iovec *iv, size_t count,
454 int noblock)
455{
456 struct sk_buff *skb;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000457 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000458 size_t len = count;
459 int err;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000460 struct virtio_net_hdr vnet_hdr = { 0 };
461 int vnet_hdr_len = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000462
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000463 if (q->flags & IFF_VNET_HDR) {
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300464 vnet_hdr_len = q->vnet_hdr_sz;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000465
466 err = -EINVAL;
467 if ((len -= vnet_hdr_len) < 0)
468 goto err;
469
470 err = memcpy_fromiovecend((void *)&vnet_hdr, iv, 0,
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300471 sizeof(vnet_hdr));
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000472 if (err < 0)
473 goto err;
474 if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
475 vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 >
476 vnet_hdr.hdr_len)
477 vnet_hdr.hdr_len = vnet_hdr.csum_start +
478 vnet_hdr.csum_offset + 2;
479 err = -EINVAL;
480 if (vnet_hdr.hdr_len > len)
481 goto err;
482 }
483
484 err = -EINVAL;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000485 if (unlikely(len < ETH_HLEN))
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000486 goto err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000487
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000488 skb = macvtap_alloc_skb(&q->sk, NET_IP_ALIGN, len, vnet_hdr.hdr_len,
489 noblock, &err);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000490 if (!skb)
491 goto err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000492
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000493 err = skb_copy_datagram_from_iovec(skb, 0, iv, vnet_hdr_len, len);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000494 if (err)
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000495 goto err_kfree;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000496
497 skb_set_network_header(skb, ETH_HLEN);
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000498 skb_reset_mac_header(skb);
499 skb->protocol = eth_hdr(skb)->h_proto;
500
501 if (vnet_hdr_len) {
502 err = macvtap_skb_from_vnet_hdr(skb, &vnet_hdr);
503 if (err)
504 goto err_kfree;
505 }
506
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000507 rcu_read_lock_bh();
508 vlan = rcu_dereference(q->vlan);
509 if (vlan)
510 macvlan_start_xmit(skb, vlan->dev);
511 else
512 kfree_skb(skb);
513 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000514
515 return count;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000516
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000517err_kfree:
518 kfree_skb(skb);
519
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000520err:
521 rcu_read_lock_bh();
522 vlan = rcu_dereference(q->vlan);
523 if (vlan)
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000524 netdev_get_tx_queue(vlan->dev, 0)->tx_dropped++;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000525 rcu_read_unlock_bh();
526
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000527 return err;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000528}
529
530static ssize_t macvtap_aio_write(struct kiocb *iocb, const struct iovec *iv,
531 unsigned long count, loff_t pos)
532{
533 struct file *file = iocb->ki_filp;
534 ssize_t result = -ENOLINK;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000535 struct macvtap_queue *q = file->private_data;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000536
537 result = macvtap_get_user(q, iv, iov_length(iv, count),
538 file->f_flags & O_NONBLOCK);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000539 return result;
540}
541
542/* Put packet to the user space buffer */
543static ssize_t macvtap_put_user(struct macvtap_queue *q,
544 const struct sk_buff *skb,
545 const struct iovec *iv, int len)
546{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000547 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000548 int ret;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000549 int vnet_hdr_len = 0;
550
551 if (q->flags & IFF_VNET_HDR) {
552 struct virtio_net_hdr vnet_hdr;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300553 vnet_hdr_len = q->vnet_hdr_sz;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000554 if ((len -= vnet_hdr_len) < 0)
555 return -EINVAL;
556
557 ret = macvtap_skb_to_vnet_hdr(skb, &vnet_hdr);
558 if (ret)
559 return ret;
560
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300561 if (memcpy_toiovecend(iv, (void *)&vnet_hdr, 0, sizeof(vnet_hdr)))
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000562 return -EFAULT;
563 }
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000564
565 len = min_t(int, skb->len, len);
566
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000567 ret = skb_copy_datagram_const_iovec(skb, 0, iv, vnet_hdr_len, len);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000568
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000569 rcu_read_lock_bh();
570 vlan = rcu_dereference(q->vlan);
Arnd Bergmann501c7742010-02-18 05:46:50 +0000571 if (vlan)
572 macvlan_count_rx(vlan, len, ret == 0, 0);
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000573 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000574
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000575 return ret ? ret : (len + vnet_hdr_len);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000576}
577
Arnd Bergmann501c7742010-02-18 05:46:50 +0000578static ssize_t macvtap_do_read(struct macvtap_queue *q, struct kiocb *iocb,
579 const struct iovec *iv, unsigned long len,
580 int noblock)
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000581{
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000582 DECLARE_WAITQUEUE(wait, current);
583 struct sk_buff *skb;
Arnd Bergmann501c7742010-02-18 05:46:50 +0000584 ssize_t ret = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000585
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000586 add_wait_queue(sk_sleep(&q->sk), &wait);
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000587 while (len) {
588 current->state = TASK_INTERRUPTIBLE;
589
590 /* Read frames from the queue */
591 skb = skb_dequeue(&q->sk.sk_receive_queue);
592 if (!skb) {
Arnd Bergmann501c7742010-02-18 05:46:50 +0000593 if (noblock) {
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000594 ret = -EAGAIN;
595 break;
596 }
597 if (signal_pending(current)) {
598 ret = -ERESTARTSYS;
599 break;
600 }
601 /* Nothing to read, let's sleep */
602 schedule();
603 continue;
604 }
605 ret = macvtap_put_user(q, skb, iv, len);
606 kfree_skb(skb);
607 break;
608 }
609
610 current->state = TASK_RUNNING;
Eric Dumazet4a4771a2010-04-25 22:20:06 +0000611 remove_wait_queue(sk_sleep(&q->sk), &wait);
Arnd Bergmann501c7742010-02-18 05:46:50 +0000612 return ret;
613}
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000614
Arnd Bergmann501c7742010-02-18 05:46:50 +0000615static ssize_t macvtap_aio_read(struct kiocb *iocb, const struct iovec *iv,
616 unsigned long count, loff_t pos)
617{
618 struct file *file = iocb->ki_filp;
619 struct macvtap_queue *q = file->private_data;
620 ssize_t len, ret = 0;
621
622 len = iov_length(iv, count);
623 if (len < 0) {
624 ret = -EINVAL;
625 goto out;
626 }
627
628 ret = macvtap_do_read(q, iocb, iv, len, file->f_flags & O_NONBLOCK);
629 ret = min_t(ssize_t, ret, len); /* XXX copied from tun.c. Why? */
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000630out:
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000631 return ret;
632}
633
634/*
635 * provide compatibility with generic tun/tap interface
636 */
637static long macvtap_ioctl(struct file *file, unsigned int cmd,
638 unsigned long arg)
639{
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000640 struct macvtap_queue *q = file->private_data;
641 struct macvlan_dev *vlan;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000642 void __user *argp = (void __user *)arg;
643 struct ifreq __user *ifr = argp;
644 unsigned int __user *up = argp;
645 unsigned int u;
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300646 int __user *sp = argp;
647 int s;
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000648 int ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000649
650 switch (cmd) {
651 case TUNSETIFF:
652 /* ignore the name, just look at flags */
653 if (get_user(u, &ifr->ifr_flags))
654 return -EFAULT;
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000655
656 ret = 0;
657 if ((u & ~IFF_VNET_HDR) != (IFF_NO_PI | IFF_TAP))
658 ret = -EINVAL;
659 else
660 q->flags = u;
661
662 return ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000663
664 case TUNGETIFF:
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000665 rcu_read_lock_bh();
666 vlan = rcu_dereference(q->vlan);
667 if (vlan)
668 dev_hold(vlan->dev);
669 rcu_read_unlock_bh();
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000670
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000671 if (!vlan)
672 return -ENOLINK;
673
674 ret = 0;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000675 if (copy_to_user(&ifr->ifr_name, q->vlan->dev->name, IFNAMSIZ) ||
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000676 put_user(q->flags, &ifr->ifr_flags))
Arnd Bergmann02df55d2010-02-18 05:45:36 +0000677 ret = -EFAULT;
678 dev_put(vlan->dev);
679 return ret;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000680
681 case TUNGETFEATURES:
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000682 if (put_user(IFF_TAP | IFF_NO_PI | IFF_VNET_HDR, up))
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000683 return -EFAULT;
684 return 0;
685
686 case TUNSETSNDBUF:
687 if (get_user(u, up))
688 return -EFAULT;
689
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000690 q->sk.sk_sndbuf = u;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000691 return 0;
692
Michael S. Tsirkin55afbd02010-04-29 13:50:48 +0300693 case TUNGETVNETHDRSZ:
694 s = q->vnet_hdr_sz;
695 if (put_user(s, sp))
696 return -EFAULT;
697 return 0;
698
699 case TUNSETVNETHDRSZ:
700 if (get_user(s, sp))
701 return -EFAULT;
702 if (s < (int)sizeof(struct virtio_net_hdr))
703 return -EINVAL;
704
705 q->vnet_hdr_sz = s;
706 return 0;
707
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000708 case TUNSETOFFLOAD:
709 /* let the user check for future flags */
710 if (arg & ~(TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6 |
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000711 TUN_F_TSO_ECN | TUN_F_UFO))
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000712 return -EINVAL;
713
Arnd Bergmannb9fb9ee2010-02-18 05:48:17 +0000714 /* TODO: only accept frames with the features that
715 got enabled for forwarded frames */
716 if (!(q->flags & IFF_VNET_HDR))
717 return -EINVAL;
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000718 return 0;
719
720 default:
721 return -EINVAL;
722 }
723}
724
725#ifdef CONFIG_COMPAT
726static long macvtap_compat_ioctl(struct file *file, unsigned int cmd,
727 unsigned long arg)
728{
729 return macvtap_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
730}
731#endif
732
733static const struct file_operations macvtap_fops = {
734 .owner = THIS_MODULE,
735 .open = macvtap_open,
736 .release = macvtap_release,
737 .aio_read = macvtap_aio_read,
738 .aio_write = macvtap_aio_write,
739 .poll = macvtap_poll,
740 .llseek = no_llseek,
741 .unlocked_ioctl = macvtap_ioctl,
742#ifdef CONFIG_COMPAT
743 .compat_ioctl = macvtap_compat_ioctl,
744#endif
745};
746
Arnd Bergmann501c7742010-02-18 05:46:50 +0000747static int macvtap_sendmsg(struct kiocb *iocb, struct socket *sock,
748 struct msghdr *m, size_t total_len)
749{
750 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock);
751 return macvtap_get_user(q, m->msg_iov, total_len,
752 m->msg_flags & MSG_DONTWAIT);
753}
754
755static int macvtap_recvmsg(struct kiocb *iocb, struct socket *sock,
756 struct msghdr *m, size_t total_len,
757 int flags)
758{
759 struct macvtap_queue *q = container_of(sock, struct macvtap_queue, sock);
760 int ret;
761 if (flags & ~(MSG_DONTWAIT|MSG_TRUNC))
762 return -EINVAL;
763 ret = macvtap_do_read(q, iocb, m->msg_iov, total_len,
764 flags & MSG_DONTWAIT);
765 if (ret > total_len) {
766 m->msg_flags |= MSG_TRUNC;
767 ret = flags & MSG_TRUNC ? ret : total_len;
768 }
769 return ret;
770}
771
772/* Ops structure to mimic raw sockets with tun */
773static const struct proto_ops macvtap_socket_ops = {
774 .sendmsg = macvtap_sendmsg,
775 .recvmsg = macvtap_recvmsg,
776};
777
778/* Get an underlying socket object from tun file. Returns error unless file is
779 * attached to a device. The returned object works like a packet socket, it
780 * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for
781 * holding a reference to the file for as long as the socket is in use. */
782struct socket *macvtap_get_socket(struct file *file)
783{
784 struct macvtap_queue *q;
785 if (file->f_op != &macvtap_fops)
786 return ERR_PTR(-EINVAL);
787 q = file->private_data;
788 if (!q)
789 return ERR_PTR(-EBADFD);
790 return &q->sock;
791}
792EXPORT_SYMBOL_GPL(macvtap_get_socket);
793
Arnd Bergmann20d29d72010-01-30 12:24:26 +0000794static int macvtap_init(void)
795{
796 int err;
797
798 err = alloc_chrdev_region(&macvtap_major, 0,
799 MACVTAP_NUM_DEVS, "macvtap");
800 if (err)
801 goto out1;
802
803 cdev_init(&macvtap_cdev, &macvtap_fops);
804 err = cdev_add(&macvtap_cdev, macvtap_major, MACVTAP_NUM_DEVS);
805 if (err)
806 goto out2;
807
808 macvtap_class = class_create(THIS_MODULE, "macvtap");
809 if (IS_ERR(macvtap_class)) {
810 err = PTR_ERR(macvtap_class);
811 goto out3;
812 }
813
814 err = macvlan_link_register(&macvtap_link_ops);
815 if (err)
816 goto out4;
817
818 return 0;
819
820out4:
821 class_unregister(macvtap_class);
822out3:
823 cdev_del(&macvtap_cdev);
824out2:
825 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS);
826out1:
827 return err;
828}
829module_init(macvtap_init);
830
831static void macvtap_exit(void)
832{
833 rtnl_link_unregister(&macvtap_link_ops);
834 class_unregister(macvtap_class);
835 cdev_del(&macvtap_cdev);
836 unregister_chrdev_region(macvtap_major, MACVTAP_NUM_DEVS);
837}
838module_exit(macvtap_exit);
839
840MODULE_ALIAS_RTNL_LINK("macvtap");
841MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
842MODULE_LICENSE("GPL");