2019-05-19 20:08:20 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-only
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <linux/etherdevice.h>
|
2017-02-11 08:03:49 +08:00
|
|
|
#include <linux/if_tap.h>
|
2012-05-04 06:55:24 +08:00
|
|
|
#include <linux/if_vlan.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/nsproxy.h>
|
|
|
|
#include <linux/compat.h>
|
|
|
|
#include <linux/if_tun.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/cache.h>
|
2017-02-02 15:35:14 +08:00
|
|
|
#include <linux/sched/signal.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <linux/types.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <linux/wait.h>
|
|
|
|
#include <linux/cdev.h>
|
2012-02-13 11:58:52 +08:00
|
|
|
#include <linux/idr.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <linux/fs.h>
|
2014-11-07 21:22:25 +08:00
|
|
|
#include <linux/uio.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2023-06-09 03:17:37 +08:00
|
|
|
#include <net/gso.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
#include <net/net_namespace.h>
|
|
|
|
#include <net/rtnetlink.h>
|
|
|
|
#include <net/sock.h>
|
2010-02-18 13:48:17 +08:00
|
|
|
#include <linux/virtio_net.h>
|
2016-07-15 15:46:31 +08:00
|
|
|
#include <linux/skb_array.h>
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
#define TAP_IFFEATURES (IFF_VNET_HDR | IFF_MULTI_QUEUE)
|
2014-12-16 21:05:10 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
#define TAP_VNET_LE 0x80000000
|
|
|
|
#define TAP_VNET_BE 0x40000000
|
2015-04-24 20:50:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_TUN_VNET_CROSS_LE
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline bool tap_legacy_is_little_endian(struct tap_queue *q)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
return q->flags & TAP_VNET_BE ? false :
|
2015-04-24 20:50:36 +08:00
|
|
|
virtio_legacy_is_little_endian();
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static long tap_get_vnet_be(struct tap_queue *q, int __user *sp)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
int s = !!(q->flags & TAP_VNET_BE);
|
2015-04-24 20:50:36 +08:00
|
|
|
|
|
|
|
if (put_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static long tap_set_vnet_be(struct tap_queue *q, int __user *sp)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
|
|
|
int s;
|
|
|
|
|
|
|
|
if (get_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
if (s)
|
2017-02-11 08:03:47 +08:00
|
|
|
q->flags |= TAP_VNET_BE;
|
2015-04-24 20:50:36 +08:00
|
|
|
else
|
2017-02-11 08:03:47 +08:00
|
|
|
q->flags &= ~TAP_VNET_BE;
|
2015-04-24 20:50:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#else
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline bool tap_legacy_is_little_endian(struct tap_queue *q)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
|
|
|
return virtio_legacy_is_little_endian();
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static long tap_get_vnet_be(struct tap_queue *q, int __user *argp)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static long tap_set_vnet_be(struct tap_queue *q, int __user *argp)
|
2015-04-24 20:50:36 +08:00
|
|
|
{
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
#endif /* CONFIG_TUN_VNET_CROSS_LE */
|
2014-11-23 23:24:15 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline bool tap_is_little_endian(struct tap_queue *q)
|
2015-04-24 20:24:48 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
return q->flags & TAP_VNET_LE ||
|
|
|
|
tap_legacy_is_little_endian(q);
|
2015-04-24 20:24:48 +08:00
|
|
|
}
|
2014-11-23 23:24:15 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline u16 tap16_to_cpu(struct tap_queue *q, __virtio16 val)
|
2014-11-23 23:24:15 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
return __virtio16_to_cpu(tap_is_little_endian(q), val);
|
2014-11-23 23:24:15 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline __virtio16 cpu_to_tap16(struct tap_queue *q, u16 val)
|
2014-11-23 23:24:15 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
return __cpu_to_virtio16(tap_is_little_endian(q), val);
|
2014-11-23 23:24:15 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static struct proto tap_proto = {
|
|
|
|
.name = "tap",
|
2010-01-30 20:24:26 +08:00
|
|
|
.owner = THIS_MODULE,
|
2017-02-11 08:03:47 +08:00
|
|
|
.obj_size = sizeof(struct tap_queue),
|
2010-01-30 20:24:26 +08:00
|
|
|
};
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
#define TAP_NUM_DEVS (1U << MINORBITS)
|
2017-02-11 08:03:50 +08:00
|
|
|
|
|
|
|
static LIST_HEAD(major_list);
|
|
|
|
|
2017-02-11 08:03:48 +08:00
|
|
|
struct major_info {
|
2017-02-11 08:03:50 +08:00
|
|
|
struct rcu_head rcu;
|
2017-02-11 08:03:48 +08:00
|
|
|
dev_t major;
|
|
|
|
struct idr minor_idr;
|
2017-07-11 01:05:50 +08:00
|
|
|
spinlock_t minor_lock;
|
2017-02-11 08:03:48 +08:00
|
|
|
const char *device_name;
|
2017-02-11 08:03:50 +08:00
|
|
|
struct list_head next;
|
|
|
|
};
|
2011-10-20 12:29:24 +08:00
|
|
|
|
2011-07-06 20:26:11 +08:00
|
|
|
#define GOODCOPY_LEN 128
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static const struct proto_ops tap_socket_ops;
|
2010-02-18 13:46:50 +08:00
|
|
|
|
2013-06-26 04:04:21 +08:00
|
|
|
#define RX_OFFLOADS (NETIF_F_GRO | NETIF_F_LRO)
|
2015-10-23 12:57:05 +08:00
|
|
|
#define TAP_FEATURES (NETIF_F_GSO | NETIF_F_SG | NETIF_F_FRAGLIST)
|
2013-08-17 03:25:00 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
static struct tap_dev *tap_dev_get_rcu(const struct net_device *dev)
|
2013-12-12 02:27:10 +08:00
|
|
|
{
|
|
|
|
return rcu_dereference(dev->rx_handler_data);
|
|
|
|
}
|
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
/*
|
|
|
|
* RCU usage:
|
2017-02-11 08:03:47 +08:00
|
|
|
* The tap_queue and the macvlan_dev are loosely coupled, the
|
2010-02-18 13:45:36 +08:00
|
|
|
* pointers from one to the other can only be read while rcu_read_lock
|
2013-06-26 04:04:19 +08:00
|
|
|
* or rtnl is held.
|
2010-01-30 20:24:26 +08:00
|
|
|
*
|
2017-02-11 08:03:47 +08:00
|
|
|
* Both the file and the macvlan_dev hold a reference on the tap_queue
|
2010-02-18 13:45:36 +08:00
|
|
|
* through sock_hold(&q->sk). When the macvlan_dev goes away first,
|
|
|
|
* q->vlan becomes inaccessible. When the files gets closed,
|
2017-02-11 08:03:47 +08:00
|
|
|
* tap_get_queue() fails.
|
2010-01-30 20:24:26 +08:00
|
|
|
*
|
2010-02-18 13:45:36 +08:00
|
|
|
* There may still be references to the struct sock inside of the
|
|
|
|
* queue from outbound SKBs, but these never reference back to the
|
|
|
|
* file or the dev. The data structure is freed through __sk_free
|
|
|
|
* when both our references and any pending SKBs are gone.
|
2010-01-30 20:24:26 +08:00
|
|
|
*/
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
static int tap_enable_queue(struct tap_dev *tap, struct file *file,
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q)
|
2013-06-06 07:54:39 +08:00
|
|
|
{
|
|
|
|
int err = -EINVAL;
|
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
ASSERT_RTNL();
|
2013-06-06 07:54:39 +08:00
|
|
|
|
|
|
|
if (q->enabled)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
err = 0;
|
2017-02-11 08:03:49 +08:00
|
|
|
rcu_assign_pointer(tap->taps[tap->numvtaps], q);
|
|
|
|
q->queue_index = tap->numvtaps;
|
2013-06-06 07:54:39 +08:00
|
|
|
q->enabled = true;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numvtaps++;
|
2013-06-06 07:54:39 +08:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2014-09-23 04:34:17 +08:00
|
|
|
/* Requires RTNL */
|
2017-02-11 08:03:49 +08:00
|
|
|
static int tap_set_queue(struct tap_dev *tap, struct file *file,
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap->numqueues == MAX_TAP_QUEUES)
|
2014-09-23 04:34:17 +08:00
|
|
|
return -EBUSY;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
rcu_assign_pointer(q->tap, tap);
|
|
|
|
rcu_assign_pointer(tap->taps[tap->numvtaps], q);
|
2010-02-18 13:45:36 +08:00
|
|
|
sock_hold(&q->sk);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
q->file = file;
|
2017-02-11 08:03:49 +08:00
|
|
|
q->queue_index = tap->numvtaps;
|
2013-06-06 07:54:39 +08:00
|
|
|
q->enabled = true;
|
2010-02-18 13:45:36 +08:00
|
|
|
file->private_data = q;
|
2017-02-11 08:03:49 +08:00
|
|
|
list_add_tail(&q->next, &tap->queue_list);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numvtaps++;
|
|
|
|
tap->numqueues++;
|
2010-08-04 14:15:59 +08:00
|
|
|
|
2014-09-23 04:34:17 +08:00
|
|
|
return 0;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_disable_queue(struct tap_queue *q)
|
2013-06-06 07:54:39 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *nq;
|
2013-06-06 07:54:39 +08:00
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
ASSERT_RTNL();
|
2013-06-06 07:54:39 +08:00
|
|
|
if (!q->enabled)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = rtnl_dereference(q->tap);
|
2013-06-26 04:04:19 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap) {
|
2013-06-06 07:54:39 +08:00
|
|
|
int index = q->queue_index;
|
2017-02-11 08:03:49 +08:00
|
|
|
BUG_ON(index >= tap->numvtaps);
|
|
|
|
nq = rtnl_dereference(tap->taps[tap->numvtaps - 1]);
|
2013-06-06 07:54:39 +08:00
|
|
|
nq->queue_index = index;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
rcu_assign_pointer(tap->taps[index], nq);
|
|
|
|
RCU_INIT_POINTER(tap->taps[tap->numvtaps - 1], NULL);
|
2013-06-06 07:54:39 +08:00
|
|
|
q->enabled = false;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numvtaps--;
|
2013-06-06 07:54:39 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
/*
|
2010-02-18 13:45:36 +08:00
|
|
|
* The file owning the queue got closed, give up both
|
|
|
|
* the reference that the files holds as well as the
|
|
|
|
* one from the macvlan_dev if that still exists.
|
2010-01-30 20:24:26 +08:00
|
|
|
*
|
|
|
|
* Using the spinlock makes sure that we don't get
|
|
|
|
* to the queue again after destroying it.
|
|
|
|
*/
|
2017-02-11 08:03:47 +08:00
|
|
|
static void tap_put_queue(struct tap_queue *q)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_lock();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = rtnl_dereference(q->tap);
|
2013-06-26 04:04:19 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap) {
|
2013-06-06 07:54:39 +08:00
|
|
|
if (q->enabled)
|
2017-02-11 08:03:47 +08:00
|
|
|
BUG_ON(tap_disable_queue(q));
|
2013-06-06 07:54:38 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numqueues--;
|
|
|
|
RCU_INIT_POINTER(q->tap, NULL);
|
2010-02-18 13:45:36 +08:00
|
|
|
sock_put(&q->sk);
|
2013-06-06 07:54:39 +08:00
|
|
|
list_del_init(&q->next);
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_unlock();
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
synchronize_rcu();
|
|
|
|
sock_put(&q->sk);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-08-04 14:15:59 +08:00
|
|
|
* Select a queue based on the rxq of the device on which this packet
|
|
|
|
* arrived. If the incoming device is not mq, calculate a flow hash
|
|
|
|
* to select a queue. If all fails, find the first available queue.
|
|
|
|
* Cache vlan->numvtaps since it can become zero during the execution
|
|
|
|
* of this function.
|
2010-01-30 20:24:26 +08:00
|
|
|
*/
|
2017-02-11 08:03:49 +08:00
|
|
|
static struct tap_queue *tap_get_queue(struct tap_dev *tap,
|
2017-02-11 08:03:47 +08:00
|
|
|
struct sk_buff *skb)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_queue *queue = NULL;
|
2013-06-06 07:54:39 +08:00
|
|
|
/* Access to taps array is protected by rcu, but access to numvtaps
|
|
|
|
* isn't. Below we use it to lookup a queue, but treat it as a hint
|
|
|
|
* and validate that the result isn't NULL - in case we are
|
|
|
|
* racing against queue removal.
|
|
|
|
*/
|
locking/atomics: COCCINELLE/treewide: Convert trivial ACCESS_ONCE() patterns to READ_ONCE()/WRITE_ONCE()
Please do not apply this to mainline directly, instead please re-run the
coccinelle script shown below and apply its output.
For several reasons, it is desirable to use {READ,WRITE}_ONCE() in
preference to ACCESS_ONCE(), and new code is expected to use one of the
former. So far, there's been no reason to change most existing uses of
ACCESS_ONCE(), as these aren't harmful, and changing them results in
churn.
However, for some features, the read/write distinction is critical to
correct operation. To distinguish these cases, separate read/write
accessors must be used. This patch migrates (most) remaining
ACCESS_ONCE() instances to {READ,WRITE}_ONCE(), using the following
coccinelle script:
----
// Convert trivial ACCESS_ONCE() uses to equivalent READ_ONCE() and
// WRITE_ONCE()
// $ make coccicheck COCCI=/home/mark/once.cocci SPFLAGS="--include-headers" MODE=patch
virtual patch
@ depends on patch @
expression E1, E2;
@@
- ACCESS_ONCE(E1) = E2
+ WRITE_ONCE(E1, E2)
@ depends on patch @
expression E;
@@
- ACCESS_ONCE(E)
+ READ_ONCE(E)
----
Signed-off-by: Mark Rutland <mark.rutland@arm.com>
Signed-off-by: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: davem@davemloft.net
Cc: linux-arch@vger.kernel.org
Cc: mpe@ellerman.id.au
Cc: shuah@kernel.org
Cc: snitzer@redhat.com
Cc: thor.thayer@linux.intel.com
Cc: tj@kernel.org
Cc: viro@zeniv.linux.org.uk
Cc: will.deacon@arm.com
Link: http://lkml.kernel.org/r/1508792849-3115-19-git-send-email-paulmck@linux.vnet.ibm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2017-10-24 05:07:29 +08:00
|
|
|
int numvtaps = READ_ONCE(tap->numvtaps);
|
2010-08-04 14:15:59 +08:00
|
|
|
__u32 rxq;
|
|
|
|
|
|
|
|
if (!numvtaps)
|
|
|
|
goto out;
|
|
|
|
|
2016-07-15 15:46:30 +08:00
|
|
|
if (numvtaps == 1)
|
|
|
|
goto single;
|
|
|
|
|
2011-11-24 06:17:14 +08:00
|
|
|
/* Check if we can use flow to select a queue */
|
2013-12-16 14:12:06 +08:00
|
|
|
rxq = skb_get_hash(skb);
|
2011-11-24 06:17:14 +08:00
|
|
|
if (rxq) {
|
2017-02-11 08:03:49 +08:00
|
|
|
queue = rcu_dereference(tap->taps[rxq % numvtaps]);
|
2013-06-06 07:54:38 +08:00
|
|
|
goto out;
|
2011-11-24 06:17:14 +08:00
|
|
|
}
|
|
|
|
|
2010-08-04 14:15:59 +08:00
|
|
|
if (likely(skb_rx_queue_recorded(skb))) {
|
|
|
|
rxq = skb_get_rx_queue(skb);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2010-08-04 14:15:59 +08:00
|
|
|
while (unlikely(rxq >= numvtaps))
|
|
|
|
rxq -= numvtaps;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
queue = rcu_dereference(tap->taps[rxq]);
|
2013-06-06 07:54:38 +08:00
|
|
|
goto out;
|
2010-08-04 14:15:59 +08:00
|
|
|
}
|
|
|
|
|
2016-07-15 15:46:30 +08:00
|
|
|
single:
|
2017-02-11 08:03:49 +08:00
|
|
|
queue = rcu_dereference(tap->taps[0]);
|
2010-08-04 14:15:59 +08:00
|
|
|
out:
|
2017-02-11 08:03:49 +08:00
|
|
|
return queue;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2010-02-18 13:45:36 +08:00
|
|
|
/*
|
|
|
|
* The net_device is going away, give up the reference
|
2010-08-04 14:15:59 +08:00
|
|
|
* that it holds on all queues and safely set the pointer
|
|
|
|
* from the queues to NULL.
|
2010-02-18 13:45:36 +08:00
|
|
|
*/
|
2017-02-11 08:03:49 +08:00
|
|
|
void tap_del_queues(struct tap_dev *tap)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q, *tmp;
|
2010-02-18 13:45:36 +08:00
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
ASSERT_RTNL();
|
2017-02-11 08:03:49 +08:00
|
|
|
list_for_each_entry_safe(q, tmp, &tap->queue_list, next) {
|
2013-06-06 07:54:39 +08:00
|
|
|
list_del_init(&q->next);
|
2017-02-11 08:03:49 +08:00
|
|
|
RCU_INIT_POINTER(q->tap, NULL);
|
2013-06-06 07:54:39 +08:00
|
|
|
if (q->enabled)
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numvtaps--;
|
|
|
|
tap->numqueues--;
|
2015-06-19 22:17:53 +08:00
|
|
|
sock_put(&q->sk);
|
2010-02-11 13:55:39 +08:00
|
|
|
}
|
2017-02-11 08:03:49 +08:00
|
|
|
BUG_ON(tap->numvtaps);
|
|
|
|
BUG_ON(tap->numqueues);
|
2017-02-11 08:03:47 +08:00
|
|
|
/* guarantee that any future tap_set_queue will fail */
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->numvtaps = MAX_TAP_QUEUES;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_del_queues);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
rx_handler_result_t tap_handle_frame(struct sk_buff **pskb)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2013-12-12 02:27:10 +08:00
|
|
|
struct sk_buff *skb = *pskb;
|
|
|
|
struct net_device *dev = skb->dev;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q;
|
2013-08-17 03:25:00 +08:00
|
|
|
netdev_features_t features = TAP_FEATURES;
|
2022-03-04 22:55:05 +08:00
|
|
|
enum skb_drop_reason drop_reason;
|
2013-08-17 03:25:00 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = tap_dev_get_rcu(dev);
|
|
|
|
if (!tap)
|
2013-12-12 02:27:10 +08:00
|
|
|
return RX_HANDLER_PASS;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
q = tap_get_queue(tap, skb);
|
2010-01-30 20:24:26 +08:00
|
|
|
if (!q)
|
2013-12-12 02:27:10 +08:00
|
|
|
return RX_HANDLER_PASS;
|
2010-07-22 05:44:31 +08:00
|
|
|
|
2013-12-12 02:27:10 +08:00
|
|
|
skb_push(skb, ETH_HLEN);
|
|
|
|
|
2013-06-26 04:04:22 +08:00
|
|
|
/* Apply the forward feature mask so that we perform segmentation
|
2013-08-17 03:25:02 +08:00
|
|
|
* according to users wishes. This only works if VNET_HDR is
|
|
|
|
* enabled.
|
2013-06-26 04:04:22 +08:00
|
|
|
*/
|
2013-08-17 03:25:02 +08:00
|
|
|
if (q->flags & IFF_VNET_HDR)
|
2017-02-11 08:03:49 +08:00
|
|
|
features |= tap->tap_features;
|
2015-04-17 21:45:04 +08:00
|
|
|
if (netif_needs_gso(skb, features)) {
|
2013-06-26 04:04:22 +08:00
|
|
|
struct sk_buff *segs = __skb_gso_segment(skb, features, false);
|
2020-01-09 05:59:03 +08:00
|
|
|
struct sk_buff *next;
|
2013-06-26 04:04:22 +08:00
|
|
|
|
2022-03-04 22:55:05 +08:00
|
|
|
if (IS_ERR(segs)) {
|
|
|
|
drop_reason = SKB_DROP_REASON_SKB_GSO_SEG;
|
2013-06-26 04:04:22 +08:00
|
|
|
goto drop;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
2013-06-26 04:04:22 +08:00
|
|
|
|
|
|
|
if (!segs) {
|
2022-03-04 22:55:05 +08:00
|
|
|
if (ptr_ring_produce(&q->ring, skb)) {
|
|
|
|
drop_reason = SKB_DROP_REASON_FULL_RING;
|
2016-07-15 15:46:31 +08:00
|
|
|
goto drop;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
2013-06-26 04:04:22 +08:00
|
|
|
goto wake_up;
|
|
|
|
}
|
|
|
|
|
2016-05-06 20:58:21 +08:00
|
|
|
consume_skb(skb);
|
2020-01-09 05:59:03 +08:00
|
|
|
skb_list_walk_safe(segs, skb, next) {
|
|
|
|
skb_mark_not_on_list(skb);
|
|
|
|
if (ptr_ring_produce(&q->ring, skb)) {
|
2022-03-04 22:55:05 +08:00
|
|
|
drop_reason = SKB_DROP_REASON_FULL_RING;
|
|
|
|
kfree_skb_reason(skb, drop_reason);
|
|
|
|
kfree_skb_list_reason(next, drop_reason);
|
2016-07-15 15:46:31 +08:00
|
|
|
break;
|
|
|
|
}
|
2013-06-26 04:04:22 +08:00
|
|
|
}
|
|
|
|
} else {
|
2014-04-29 22:09:50 +08:00
|
|
|
/* If we receive a partial checksum and the tap side
|
|
|
|
* doesn't support checksum offload, compute the checksum.
|
|
|
|
* Note: it doesn't matter which checksum feature to
|
2017-02-11 08:03:46 +08:00
|
|
|
* check, we either support them all or none.
|
2014-04-29 22:09:50 +08:00
|
|
|
*/
|
|
|
|
if (skb->ip_summed == CHECKSUM_PARTIAL &&
|
2015-12-15 03:19:43 +08:00
|
|
|
!(features & NETIF_F_CSUM_MASK) &&
|
2022-03-04 22:55:05 +08:00
|
|
|
skb_checksum_help(skb)) {
|
|
|
|
drop_reason = SKB_DROP_REASON_SKB_CSUM;
|
2014-04-29 22:09:50 +08:00
|
|
|
goto drop;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
|
|
|
if (ptr_ring_produce(&q->ring, skb)) {
|
|
|
|
drop_reason = SKB_DROP_REASON_FULL_RING;
|
2016-07-15 15:46:31 +08:00
|
|
|
goto drop;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
2013-06-26 04:04:22 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
wake_up:
|
2018-02-12 06:34:03 +08:00
|
|
|
wake_up_interruptible_poll(sk_sleep(&q->sk), EPOLLIN | EPOLLRDNORM | EPOLLRDBAND);
|
2013-12-12 02:27:10 +08:00
|
|
|
return RX_HANDLER_CONSUMED;
|
2010-07-22 05:44:31 +08:00
|
|
|
|
|
|
|
drop:
|
2013-12-12 02:27:10 +08:00
|
|
|
/* Count errors/drops only here, thus don't care about args. */
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap->count_rx_dropped)
|
|
|
|
tap->count_rx_dropped(tap);
|
2022-03-04 22:55:05 +08:00
|
|
|
kfree_skb_reason(skb, drop_reason);
|
2013-12-12 02:27:10 +08:00
|
|
|
return RX_HANDLER_CONSUMED;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_handle_frame);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
static struct major_info *tap_get_major(int major)
|
|
|
|
{
|
|
|
|
struct major_info *tap_major;
|
|
|
|
|
|
|
|
list_for_each_entry_rcu(tap_major, &major_list, next) {
|
|
|
|
if (tap_major->major == major)
|
|
|
|
return tap_major;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
int tap_get_minor(dev_t major, struct tap_dev *tap)
|
2011-10-20 12:29:24 +08:00
|
|
|
{
|
|
|
|
int retval = -ENOMEM;
|
2017-02-11 08:03:50 +08:00
|
|
|
struct major_info *tap_major;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
tap_major = tap_get_major(MAJOR(major));
|
|
|
|
if (!tap_major) {
|
|
|
|
retval = -EINVAL;
|
|
|
|
goto unlock;
|
|
|
|
}
|
2011-10-20 12:29:24 +08:00
|
|
|
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_lock(&tap_major->minor_lock);
|
|
|
|
retval = idr_alloc(&tap_major->minor_idr, tap, 1, TAP_NUM_DEVS, GFP_ATOMIC);
|
2013-02-28 09:04:34 +08:00
|
|
|
if (retval >= 0) {
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->minor = retval;
|
2013-02-28 09:04:34 +08:00
|
|
|
} else if (retval == -ENOSPC) {
|
2017-02-11 08:03:49 +08:00
|
|
|
netdev_err(tap->dev, "Too many tap devices\n");
|
2011-10-20 12:29:24 +08:00
|
|
|
retval = -EINVAL;
|
|
|
|
}
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_unlock(&tap_major->minor_lock);
|
2017-02-11 08:03:50 +08:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
2013-02-28 09:04:34 +08:00
|
|
|
return retval < 0 ? retval : 0;
|
2011-10-20 12:29:24 +08:00
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_get_minor);
|
2011-10-20 12:29:24 +08:00
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
void tap_free_minor(dev_t major, struct tap_dev *tap)
|
2011-10-20 12:29:24 +08:00
|
|
|
{
|
2017-02-11 08:03:50 +08:00
|
|
|
struct major_info *tap_major;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
tap_major = tap_get_major(MAJOR(major));
|
|
|
|
if (!tap_major) {
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_lock(&tap_major->minor_lock);
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap->minor) {
|
2017-02-11 08:03:50 +08:00
|
|
|
idr_remove(&tap_major->minor_idr, tap->minor);
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->minor = 0;
|
2011-10-20 12:29:24 +08:00
|
|
|
}
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_unlock(&tap_major->minor_lock);
|
2017-02-11 08:03:50 +08:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
2011-10-20 12:29:24 +08:00
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_free_minor);
|
2011-10-20 12:29:24 +08:00
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
static struct tap_dev *dev_get_by_tap_file(int major, int minor)
|
2011-10-20 12:29:24 +08:00
|
|
|
{
|
|
|
|
struct net_device *dev = NULL;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2017-02-11 08:03:50 +08:00
|
|
|
struct major_info *tap_major;
|
2011-10-20 12:29:24 +08:00
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
tap_major = tap_get_major(major);
|
|
|
|
if (!tap_major) {
|
|
|
|
tap = NULL;
|
|
|
|
goto unlock;
|
|
|
|
}
|
|
|
|
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_lock(&tap_major->minor_lock);
|
2017-02-11 08:03:50 +08:00
|
|
|
tap = idr_find(&tap_major->minor_idr, minor);
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap) {
|
|
|
|
dev = tap->dev;
|
2011-10-20 12:29:24 +08:00
|
|
|
dev_hold(dev);
|
|
|
|
}
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_unlock(&tap_major->minor_lock);
|
2017-02-11 08:03:50 +08:00
|
|
|
|
|
|
|
unlock:
|
|
|
|
rcu_read_unlock();
|
2017-02-11 08:03:49 +08:00
|
|
|
return tap;
|
2011-10-20 12:29:24 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static void tap_sock_write_space(struct sock *sk)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2010-04-29 19:01:49 +08:00
|
|
|
wait_queue_head_t *wqueue;
|
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
if (!sock_writeable(sk) ||
|
2015-11-30 12:03:10 +08:00
|
|
|
!test_and_clear_bit(SOCKWQ_ASYNC_NOSPACE, &sk->sk_socket->flags))
|
2010-01-30 20:24:26 +08:00
|
|
|
return;
|
|
|
|
|
2010-04-29 19:01:49 +08:00
|
|
|
wqueue = sk_sleep(sk);
|
|
|
|
if (wqueue && waitqueue_active(wqueue))
|
2018-02-12 06:34:03 +08:00
|
|
|
wake_up_interruptible_poll(wqueue, EPOLLOUT | EPOLLWRNORM | EPOLLWRBAND);
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static void tap_sock_destruct(struct sock *sk)
|
2011-10-20 12:27:24 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = container_of(sk, struct tap_queue, sk);
|
2016-07-15 15:46:31 +08:00
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
ptr_ring_cleanup(&q->ring, __skb_array_destroy_skb);
|
2011-10-20 12:27:24 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_open(struct inode *inode, struct file *file)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
|
|
|
struct net *net = current->nsproxy->net_ns;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q;
|
2014-09-23 04:34:17 +08:00
|
|
|
int err = -ENODEV;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2014-09-23 04:34:17 +08:00
|
|
|
rtnl_lock();
|
2017-02-11 08:03:50 +08:00
|
|
|
tap = dev_get_by_tap_file(imajor(inode), iminor(inode));
|
2017-02-11 08:03:49 +08:00
|
|
|
if (!tap)
|
2016-07-15 15:46:31 +08:00
|
|
|
goto err;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
err = -ENOMEM;
|
2017-02-11 08:03:47 +08:00
|
|
|
q = (struct tap_queue *)sk_alloc(net, AF_UNSPEC, GFP_KERNEL,
|
|
|
|
&tap_proto, 0);
|
2010-01-30 20:24:26 +08:00
|
|
|
if (!q)
|
2016-07-15 15:46:31 +08:00
|
|
|
goto err;
|
2018-01-04 11:14:27 +08:00
|
|
|
if (ptr_ring_init(&q->ring, tap->dev->tx_queue_len, GFP_KERNEL)) {
|
2017-10-25 15:23:04 +08:00
|
|
|
sk_free(&q->sk);
|
|
|
|
goto err;
|
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2019-07-06 03:14:16 +08:00
|
|
|
init_waitqueue_head(&q->sock.wq.wait);
|
2010-01-30 20:24:26 +08:00
|
|
|
q->sock.type = SOCK_RAW;
|
|
|
|
q->sock.state = SS_CONNECTED;
|
2010-02-18 13:46:50 +08:00
|
|
|
q->sock.file = file;
|
2017-02-11 08:03:47 +08:00
|
|
|
q->sock.ops = &tap_socket_ops;
|
net: tap_open(): set sk_uid from current_fsuid()
Commit 66b2c338adce initializes the "sk_uid" field in the protocol socket
(struct sock) from the "/dev/tapX" device node's owner UID. Per original
commit 86741ec25462 ("net: core: Add a UID field to struct sock.",
2016-11-04), that's wrong: the idea is to cache the UID of the userspace
process that creates the socket. Commit 86741ec25462 mentions socket() and
accept(); with "tap", the action that creates the socket is
open("/dev/tapX").
Therefore the device node's owner UID is irrelevant. In most cases,
"/dev/tapX" will be owned by root, so in practice, commit 66b2c338adce has
no observable effect:
- before, "sk_uid" would be zero, due to undefined behavior
(CVE-2023-1076),
- after, "sk_uid" would be zero, due to "/dev/tapX" being owned by root.
What matters is the (fs)UID of the process performing the open(), so cache
that in "sk_uid".
Cc: Eric Dumazet <edumazet@google.com>
Cc: Lorenzo Colitti <lorenzo@google.com>
Cc: Paolo Abeni <pabeni@redhat.com>
Cc: Pietro Borrello <borrello@diag.uniroma1.it>
Cc: netdev@vger.kernel.org
Cc: stable@vger.kernel.org
Fixes: 66b2c338adce ("tap: tap_open(): correctly initialize socket uid")
Bugzilla: https://bugzilla.redhat.com/show_bug.cgi?id=2173435
Signed-off-by: Laszlo Ersek <lersek@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2023-08-01 00:42:37 +08:00
|
|
|
sock_init_data_uid(&q->sock, &q->sk, current_fsuid());
|
2017-02-11 08:03:47 +08:00
|
|
|
q->sk.sk_write_space = tap_sock_write_space;
|
|
|
|
q->sk.sk_destruct = tap_sock_destruct;
|
2010-02-18 13:48:17 +08:00
|
|
|
q->flags = IFF_VNET_HDR | IFF_NO_PI | IFF_TAP;
|
2010-04-29 18:50:48 +08:00
|
|
|
q->vnet_hdr_sz = sizeof(struct virtio_net_hdr);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2011-07-06 20:26:11 +08:00
|
|
|
/*
|
2017-02-11 08:03:47 +08:00
|
|
|
* so far only KVM virtio_net uses tap, enable zero copy between
|
2011-07-06 20:26:11 +08:00
|
|
|
* guest kernel and host kernel when lower device supports zerocopy
|
2011-10-20 12:26:39 +08:00
|
|
|
*
|
|
|
|
* The macvlan supports zerocopy iff the lower device supports zero
|
|
|
|
* copy so we don't have to look at the lower device directly.
|
2011-07-06 20:26:11 +08:00
|
|
|
*/
|
2017-02-11 08:03:49 +08:00
|
|
|
if ((tap->dev->features & NETIF_F_HIGHDMA) && (tap->dev->features & NETIF_F_SG))
|
2011-10-20 12:26:39 +08:00
|
|
|
sock_set_flag(&q->sk, SOCK_ZEROCOPY);
|
2011-07-06 20:26:11 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
err = tap_set_queue(tap, file, q);
|
2017-10-25 15:23:04 +08:00
|
|
|
if (err) {
|
2018-01-04 11:14:27 +08:00
|
|
|
/* tap_sock_destruct() will take care of freeing ptr_ring */
|
2017-10-25 15:23:04 +08:00
|
|
|
goto err_put;
|
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2023-03-08 12:18:21 +08:00
|
|
|
/* tap groks IOCB_NOWAIT just fine, mark it as such */
|
|
|
|
file->f_mode |= FMODE_NOWAIT;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
dev_put(tap->dev);
|
2016-07-15 15:46:31 +08:00
|
|
|
|
|
|
|
rtnl_unlock();
|
|
|
|
return err;
|
|
|
|
|
2017-10-25 15:23:04 +08:00
|
|
|
err_put:
|
2016-07-15 15:46:31 +08:00
|
|
|
sock_put(&q->sk);
|
|
|
|
err:
|
2017-02-11 08:03:49 +08:00
|
|
|
if (tap)
|
|
|
|
dev_put(tap->dev);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2014-09-23 04:34:17 +08:00
|
|
|
rtnl_unlock();
|
2010-01-30 20:24:26 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_release(struct inode *inode, struct file *file)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
|
|
|
tap_put_queue(q);
|
2010-01-30 20:24:26 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-07-03 18:39:46 +08:00
|
|
|
static __poll_t tap_poll(struct file *file, poll_table *wait)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
2018-02-12 06:34:03 +08:00
|
|
|
__poll_t mask = EPOLLERR;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
if (!q)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
mask = 0;
|
2019-07-06 03:14:16 +08:00
|
|
|
poll_wait(file, &q->sock.wq.wait, wait);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
if (!ptr_ring_empty(&q->ring))
|
2018-02-12 06:34:03 +08:00
|
|
|
mask |= EPOLLIN | EPOLLRDNORM;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
if (sock_writeable(&q->sk) ||
|
2015-11-30 12:03:10 +08:00
|
|
|
(!test_and_set_bit(SOCKWQ_ASYNC_NOSPACE, &q->sock.flags) &&
|
2010-01-30 20:24:26 +08:00
|
|
|
sock_writeable(&q->sk)))
|
2018-02-12 06:34:03 +08:00
|
|
|
mask |= EPOLLOUT | EPOLLWRNORM;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
return mask;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static inline struct sk_buff *tap_alloc_skb(struct sock *sk, size_t prepad,
|
|
|
|
size_t len, size_t linear,
|
2010-02-18 13:48:17 +08:00
|
|
|
int noblock, int *err)
|
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
|
|
|
/* Under a page? Don't bother with paged skb. */
|
|
|
|
if (prepad + len < PAGE_SIZE || !linear)
|
|
|
|
linear = len;
|
|
|
|
|
|
|
|
skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock,
|
2013-08-09 05:38:47 +08:00
|
|
|
err, 0);
|
2010-02-18 13:48:17 +08:00
|
|
|
if (!skb)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
skb_reserve(skb, prepad);
|
|
|
|
skb_put(skb, linear);
|
|
|
|
skb->data_len = len - linear;
|
|
|
|
skb->len += len - linear;
|
|
|
|
|
|
|
|
return skb;
|
|
|
|
}
|
|
|
|
|
2015-02-28 10:35:35 +08:00
|
|
|
/* Neighbour code has some assumptions on HH_DATA_MOD alignment */
|
2017-02-11 08:03:47 +08:00
|
|
|
#define TAP_RESERVE HH_DATA_OFF(ETH_HLEN)
|
2015-02-28 10:35:35 +08:00
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
/* Get packet from user space buffer */
|
2018-09-12 11:17:06 +08:00
|
|
|
static ssize_t tap_get_user(struct tap_queue *q, void *msg_control,
|
2017-02-11 08:03:47 +08:00
|
|
|
struct iov_iter *from, int noblock)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
int good_linear = SKB_MAX_HEAD(TAP_RESERVE);
|
2010-01-30 20:24:26 +08:00
|
|
|
struct sk_buff *skb;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2014-06-20 03:36:49 +08:00
|
|
|
unsigned long total_len = iov_iter_count(from);
|
2011-07-06 20:26:11 +08:00
|
|
|
unsigned long len = total_len;
|
2010-01-30 20:24:26 +08:00
|
|
|
int err;
|
2010-02-18 13:48:17 +08:00
|
|
|
struct virtio_net_hdr vnet_hdr = { 0 };
|
|
|
|
int vnet_hdr_len = 0;
|
2012-05-02 11:42:15 +08:00
|
|
|
int copylen = 0;
|
2015-07-23 22:37:43 +08:00
|
|
|
int depth;
|
2011-07-06 20:26:11 +08:00
|
|
|
bool zerocopy = false;
|
2013-07-10 13:43:28 +08:00
|
|
|
size_t linear;
|
2022-03-04 22:55:05 +08:00
|
|
|
enum skb_drop_reason drop_reason;
|
2010-02-18 13:48:17 +08:00
|
|
|
|
|
|
|
if (q->flags & IFF_VNET_HDR) {
|
2017-02-04 07:20:49 +08:00
|
|
|
vnet_hdr_len = READ_ONCE(q->vnet_hdr_sz);
|
2010-02-18 13:48:17 +08:00
|
|
|
|
|
|
|
err = -EINVAL;
|
2011-03-04 21:49:41 +08:00
|
|
|
if (len < vnet_hdr_len)
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err;
|
2011-03-04 21:49:41 +08:00
|
|
|
len -= vnet_hdr_len;
|
2010-02-18 13:48:17 +08:00
|
|
|
|
2014-06-20 03:36:49 +08:00
|
|
|
err = -EFAULT;
|
2016-11-02 10:09:04 +08:00
|
|
|
if (!copy_from_iter_full(&vnet_hdr, sizeof(vnet_hdr), from))
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err;
|
2014-06-20 03:36:49 +08:00
|
|
|
iov_iter_advance(from, vnet_hdr_len - sizeof(vnet_hdr));
|
2010-02-18 13:48:17 +08:00
|
|
|
if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) &&
|
2017-02-11 08:03:47 +08:00
|
|
|
tap16_to_cpu(q, vnet_hdr.csum_start) +
|
|
|
|
tap16_to_cpu(q, vnet_hdr.csum_offset) + 2 >
|
|
|
|
tap16_to_cpu(q, vnet_hdr.hdr_len))
|
|
|
|
vnet_hdr.hdr_len = cpu_to_tap16(q,
|
|
|
|
tap16_to_cpu(q, vnet_hdr.csum_start) +
|
|
|
|
tap16_to_cpu(q, vnet_hdr.csum_offset) + 2);
|
2010-02-18 13:48:17 +08:00
|
|
|
err = -EINVAL;
|
2017-02-11 08:03:47 +08:00
|
|
|
if (tap16_to_cpu(q, vnet_hdr.hdr_len) > len)
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err;
|
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2010-02-18 13:48:17 +08:00
|
|
|
err = -EINVAL;
|
2010-01-30 20:24:26 +08:00
|
|
|
if (unlikely(len < ETH_HLEN))
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2018-09-12 11:17:06 +08:00
|
|
|
if (msg_control && sock_flag(&q->sk, SOCK_ZEROCOPY)) {
|
2014-06-20 03:36:49 +08:00
|
|
|
struct iov_iter i;
|
|
|
|
|
2014-11-23 23:24:15 +08:00
|
|
|
copylen = vnet_hdr.hdr_len ?
|
2017-02-11 08:03:47 +08:00
|
|
|
tap16_to_cpu(q, vnet_hdr.hdr_len) : GOODCOPY_LEN;
|
2013-11-13 14:00:40 +08:00
|
|
|
if (copylen > good_linear)
|
|
|
|
copylen = good_linear;
|
2016-03-09 04:18:54 +08:00
|
|
|
else if (copylen < ETH_HLEN)
|
|
|
|
copylen = ETH_HLEN;
|
2013-07-10 13:43:28 +08:00
|
|
|
linear = copylen;
|
2014-06-20 03:36:49 +08:00
|
|
|
i = *from;
|
|
|
|
iov_iter_advance(&i, copylen);
|
|
|
|
if (iov_iter_npages(&i, INT_MAX) <= MAX_SKB_FRAGS)
|
2013-07-18 10:55:16 +08:00
|
|
|
zerocopy = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!zerocopy) {
|
2011-07-06 20:26:11 +08:00
|
|
|
copylen = len;
|
2017-02-11 08:03:47 +08:00
|
|
|
linear = tap16_to_cpu(q, vnet_hdr.hdr_len);
|
2016-03-09 04:18:54 +08:00
|
|
|
if (linear > good_linear)
|
2013-11-13 14:00:40 +08:00
|
|
|
linear = good_linear;
|
2016-03-09 04:18:54 +08:00
|
|
|
else if (linear < ETH_HLEN)
|
|
|
|
linear = ETH_HLEN;
|
2013-07-10 13:43:28 +08:00
|
|
|
}
|
2011-07-06 20:26:11 +08:00
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
skb = tap_alloc_skb(&q->sk, TAP_RESERVE, copylen,
|
|
|
|
linear, noblock, &err);
|
2010-02-18 13:45:36 +08:00
|
|
|
if (!skb)
|
|
|
|
goto err;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2012-05-02 11:42:06 +08:00
|
|
|
if (zerocopy)
|
2014-06-20 03:36:49 +08:00
|
|
|
err = zerocopy_sg_from_iter(skb, from);
|
2016-11-30 13:17:52 +08:00
|
|
|
else
|
2014-06-20 03:36:49 +08:00
|
|
|
err = skb_copy_datagram_from_iter(skb, 0, from, len);
|
2013-07-18 10:55:16 +08:00
|
|
|
|
2022-03-04 22:55:05 +08:00
|
|
|
if (err) {
|
|
|
|
drop_reason = SKB_DROP_REASON_SKB_UCOPY_FAULT;
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err_kfree;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
skb_set_network_header(skb, ETH_HLEN);
|
2010-02-18 13:48:17 +08:00
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
skb->protocol = eth_hdr(skb)->h_proto;
|
|
|
|
|
2022-08-03 14:27:59 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
tap = rcu_dereference(q->tap);
|
|
|
|
if (!tap) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return total_len;
|
|
|
|
}
|
|
|
|
skb->dev = tap->dev;
|
|
|
|
|
2010-02-18 13:48:17 +08:00
|
|
|
if (vnet_hdr_len) {
|
2016-06-08 21:09:19 +08:00
|
|
|
err = virtio_net_hdr_to_skb(skb, &vnet_hdr,
|
2017-02-11 08:03:47 +08:00
|
|
|
tap_is_little_endian(q));
|
2022-03-04 22:55:05 +08:00
|
|
|
if (err) {
|
2022-08-03 14:27:59 +08:00
|
|
|
rcu_read_unlock();
|
2022-03-04 22:55:05 +08:00
|
|
|
drop_reason = SKB_DROP_REASON_DEV_HDR;
|
2010-02-18 13:48:17 +08:00
|
|
|
goto err_kfree;
|
2022-03-04 22:55:05 +08:00
|
|
|
}
|
2010-02-18 13:48:17 +08:00
|
|
|
}
|
|
|
|
|
net: Don't set transport offset to invalid value
If the socket was created with socket(AF_PACKET, SOCK_RAW, 0),
skb->protocol will be unset, __skb_flow_dissect() will fail, and
skb_probe_transport_header() will fall back to the offset_hint, making
the resulting skb_transport_offset incorrect.
If, however, there is no transport header in the packet,
transport_header shouldn't be set to an arbitrary value.
Fix it by leaving the transport offset unset if it couldn't be found, to
be explicit rather than to fill it with some wrong value. It changes the
behavior, but if some code relied on the old behavior, it would be
broken anyway, as the old one is incorrect.
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 20:39:57 +08:00
|
|
|
skb_probe_transport_header(skb);
|
2013-03-26 04:19:55 +08:00
|
|
|
|
2015-07-23 22:37:43 +08:00
|
|
|
/* Move network header to the right position for VLAN tagged packets */
|
2021-01-15 10:32:38 +08:00
|
|
|
if (eth_type_vlan(skb->protocol) &&
|
2023-05-09 21:18:57 +08:00
|
|
|
vlan_get_protocol_and_depth(skb, skb->protocol, &depth) != 0)
|
2015-07-23 22:37:43 +08:00
|
|
|
skb_set_network_header(skb, depth);
|
|
|
|
|
2011-07-06 20:26:11 +08:00
|
|
|
/* copy skb_ubuf_info for callback when skb has no error */
|
2012-05-02 11:42:06 +08:00
|
|
|
if (zerocopy) {
|
2021-01-07 06:18:40 +08:00
|
|
|
skb_zcopy_init(skb, msg_control);
|
2018-09-12 11:17:06 +08:00
|
|
|
} else if (msg_control) {
|
|
|
|
struct ubuf_info *uarg = msg_control;
|
2021-01-07 06:18:34 +08:00
|
|
|
uarg->callback(NULL, uarg, false);
|
2012-05-02 11:42:06 +08:00
|
|
|
}
|
2016-11-30 13:17:52 +08:00
|
|
|
|
2022-08-03 14:27:59 +08:00
|
|
|
dev_queue_xmit(skb);
|
2013-06-26 04:04:20 +08:00
|
|
|
rcu_read_unlock();
|
2011-07-06 20:26:11 +08:00
|
|
|
return total_len;
|
2010-02-18 13:45:36 +08:00
|
|
|
|
2010-02-18 13:48:17 +08:00
|
|
|
err_kfree:
|
2022-03-04 22:55:05 +08:00
|
|
|
kfree_skb_reason(skb, drop_reason);
|
2010-02-18 13:48:17 +08:00
|
|
|
|
2010-02-18 13:45:36 +08:00
|
|
|
err:
|
2013-06-26 04:04:20 +08:00
|
|
|
rcu_read_lock();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = rcu_dereference(q->tap);
|
|
|
|
if (tap && tap->count_tx_dropped)
|
|
|
|
tap->count_tx_dropped(tap);
|
2013-06-26 04:04:20 +08:00
|
|
|
rcu_read_unlock();
|
2010-02-18 13:45:36 +08:00
|
|
|
|
|
|
|
return err;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static ssize_t tap_write_iter(struct kiocb *iocb, struct iov_iter *from)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
2023-03-08 12:18:21 +08:00
|
|
|
int noblock = 0;
|
|
|
|
|
|
|
|
if ((file->f_flags & O_NONBLOCK) || (iocb->ki_flags & IOCB_NOWAIT))
|
|
|
|
noblock = 1;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2023-03-08 12:18:21 +08:00
|
|
|
return tap_get_user(q, NULL, from, noblock);
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Put packet to the user space buffer */
|
2017-02-11 08:03:47 +08:00
|
|
|
static ssize_t tap_put_user(struct tap_queue *q,
|
|
|
|
const struct sk_buff *skb,
|
|
|
|
struct iov_iter *iter)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
|
|
|
int ret;
|
2010-02-18 13:48:17 +08:00
|
|
|
int vnet_hdr_len = 0;
|
2012-05-04 06:55:24 +08:00
|
|
|
int vlan_offset = 0;
|
2014-11-07 21:22:25 +08:00
|
|
|
int total;
|
2010-02-18 13:48:17 +08:00
|
|
|
|
|
|
|
if (q->flags & IFF_VNET_HDR) {
|
2018-06-06 23:23:01 +08:00
|
|
|
int vlan_hlen = skb_vlan_tag_present(skb) ? VLAN_HLEN : 0;
|
2010-02-18 13:48:17 +08:00
|
|
|
struct virtio_net_hdr vnet_hdr;
|
2018-06-06 23:23:01 +08:00
|
|
|
|
2017-02-04 07:20:49 +08:00
|
|
|
vnet_hdr_len = READ_ONCE(q->vnet_hdr_sz);
|
2014-11-07 21:22:25 +08:00
|
|
|
if (iov_iter_count(iter) < vnet_hdr_len)
|
2010-02-18 13:48:17 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2016-11-19 07:40:38 +08:00
|
|
|
if (virtio_net_hdr_from_skb(skb, &vnet_hdr,
|
2018-06-06 23:23:01 +08:00
|
|
|
tap_is_little_endian(q), true,
|
|
|
|
vlan_hlen))
|
2016-06-08 21:09:19 +08:00
|
|
|
BUG();
|
2010-02-18 13:48:17 +08:00
|
|
|
|
2014-11-07 21:22:25 +08:00
|
|
|
if (copy_to_iter(&vnet_hdr, sizeof(vnet_hdr), iter) !=
|
|
|
|
sizeof(vnet_hdr))
|
2010-02-18 13:48:17 +08:00
|
|
|
return -EFAULT;
|
2014-11-20 16:31:05 +08:00
|
|
|
|
|
|
|
iov_iter_advance(iter, vnet_hdr_len - sizeof(vnet_hdr));
|
2010-02-18 13:48:17 +08:00
|
|
|
}
|
2014-11-07 21:22:25 +08:00
|
|
|
total = vnet_hdr_len;
|
2013-12-11 13:08:34 +08:00
|
|
|
total += skb->len;
|
2012-05-04 06:55:24 +08:00
|
|
|
|
2015-01-14 00:13:44 +08:00
|
|
|
if (skb_vlan_tag_present(skb)) {
|
2012-05-04 06:55:24 +08:00
|
|
|
struct {
|
|
|
|
__be16 h_vlan_proto;
|
|
|
|
__be16 h_vlan_TCI;
|
|
|
|
} veth;
|
2013-07-16 13:36:34 +08:00
|
|
|
veth.h_vlan_proto = skb->vlan_proto;
|
2015-01-14 00:13:44 +08:00
|
|
|
veth.h_vlan_TCI = htons(skb_vlan_tag_get(skb));
|
2012-05-04 06:55:24 +08:00
|
|
|
|
|
|
|
vlan_offset = offsetof(struct vlan_ethhdr, h_vlan_proto);
|
2013-12-11 13:08:34 +08:00
|
|
|
total += VLAN_HLEN;
|
2012-05-04 06:55:24 +08:00
|
|
|
|
2014-11-07 21:22:25 +08:00
|
|
|
ret = skb_copy_datagram_iter(skb, 0, iter, vlan_offset);
|
|
|
|
if (ret || !iov_iter_count(iter))
|
2012-05-04 06:55:24 +08:00
|
|
|
goto done;
|
|
|
|
|
2014-11-07 21:22:25 +08:00
|
|
|
ret = copy_to_iter(&veth, sizeof(veth), iter);
|
|
|
|
if (ret != sizeof(veth) || !iov_iter_count(iter))
|
2012-05-04 06:55:24 +08:00
|
|
|
goto done;
|
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2014-11-07 21:22:25 +08:00
|
|
|
ret = skb_copy_datagram_iter(skb, vlan_offset, iter,
|
|
|
|
skb->len - vlan_offset);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2012-05-04 06:55:24 +08:00
|
|
|
done:
|
2013-12-11 13:08:34 +08:00
|
|
|
return ret ? ret : total;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static ssize_t tap_do_read(struct tap_queue *q,
|
|
|
|
struct iov_iter *to,
|
2017-05-17 12:14:44 +08:00
|
|
|
int noblock, struct sk_buff *skb)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2012-06-07 06:36:27 +08:00
|
|
|
DEFINE_WAIT(wait);
|
2010-02-18 13:46:50 +08:00
|
|
|
ssize_t ret = 0;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2017-12-01 18:10:38 +08:00
|
|
|
if (!iov_iter_count(to)) {
|
2018-09-20 17:37:41 +08:00
|
|
|
kfree_skb(skb);
|
2014-11-08 03:13:53 +08:00
|
|
|
return 0;
|
2017-12-01 18:10:38 +08:00
|
|
|
}
|
2014-11-08 03:13:53 +08:00
|
|
|
|
2017-05-17 12:14:44 +08:00
|
|
|
if (skb)
|
|
|
|
goto put;
|
|
|
|
|
2014-11-08 03:13:53 +08:00
|
|
|
while (1) {
|
2013-06-06 07:54:34 +08:00
|
|
|
if (!noblock)
|
|
|
|
prepare_to_wait(sk_sleep(&q->sk), &wait,
|
|
|
|
TASK_INTERRUPTIBLE);
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
/* Read frames from the queue */
|
2018-01-04 11:14:27 +08:00
|
|
|
skb = ptr_ring_consume(&q->ring);
|
2014-11-08 03:13:53 +08:00
|
|
|
if (skb)
|
|
|
|
break;
|
|
|
|
if (noblock) {
|
|
|
|
ret = -EAGAIN;
|
|
|
|
break;
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
2014-11-08 03:13:53 +08:00
|
|
|
if (signal_pending(current)) {
|
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* Nothing to read, let's sleep */
|
|
|
|
schedule();
|
|
|
|
}
|
2015-11-09 22:14:17 +08:00
|
|
|
if (!noblock)
|
|
|
|
finish_wait(sk_sleep(&q->sk), &wait);
|
|
|
|
|
2017-05-17 12:14:44 +08:00
|
|
|
put:
|
2014-11-08 03:13:53 +08:00
|
|
|
if (skb) {
|
2017-02-11 08:03:47 +08:00
|
|
|
ret = tap_put_user(q, skb, to);
|
2014-12-01 16:53:15 +08:00
|
|
|
if (unlikely(ret < 0))
|
|
|
|
kfree_skb(skb);
|
|
|
|
else
|
|
|
|
consume_skb(skb);
|
2010-01-30 20:24:26 +08:00
|
|
|
}
|
2010-02-18 13:46:50 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static ssize_t tap_read_iter(struct kiocb *iocb, struct iov_iter *to)
|
2010-02-18 13:46:50 +08:00
|
|
|
{
|
|
|
|
struct file *file = iocb->ki_filp;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
2014-11-08 03:13:53 +08:00
|
|
|
ssize_t len = iov_iter_count(to), ret;
|
2023-03-08 12:18:21 +08:00
|
|
|
int noblock = 0;
|
|
|
|
|
|
|
|
if ((file->f_flags & O_NONBLOCK) || (iocb->ki_flags & IOCB_NOWAIT))
|
|
|
|
noblock = 1;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2023-03-08 12:18:21 +08:00
|
|
|
ret = tap_do_read(q, to, noblock, NULL);
|
2013-12-11 13:08:34 +08:00
|
|
|
ret = min_t(ssize_t, ret, len);
|
2013-12-06 14:16:50 +08:00
|
|
|
if (ret > 0)
|
|
|
|
iocb->ki_pos = ret;
|
2010-01-30 20:24:26 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
static struct tap_dev *tap_get_tap_dev(struct tap_queue *q)
|
2013-06-06 07:54:36 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2013-06-06 07:54:36 +08:00
|
|
|
|
2013-06-26 04:04:19 +08:00
|
|
|
ASSERT_RTNL();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = rtnl_dereference(q->tap);
|
|
|
|
if (tap)
|
|
|
|
dev_hold(tap->dev);
|
2013-06-06 07:54:36 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
return tap;
|
2013-06-06 07:54:36 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
static void tap_put_tap_dev(struct tap_dev *tap)
|
2013-06-06 07:54:36 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
dev_put(tap->dev);
|
2013-06-06 07:54:36 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_ioctl_set_queue(struct file *file, unsigned int flags)
|
2013-06-06 07:54:39 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2013-06-06 07:54:39 +08:00
|
|
|
int ret;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = tap_get_tap_dev(q);
|
|
|
|
if (!tap)
|
2013-06-06 07:54:39 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (flags & IFF_ATTACH_QUEUE)
|
2017-02-11 08:03:49 +08:00
|
|
|
ret = tap_enable_queue(tap, file, q);
|
2013-06-06 07:54:39 +08:00
|
|
|
else if (flags & IFF_DETACH_QUEUE)
|
2017-02-11 08:03:47 +08:00
|
|
|
ret = tap_disable_queue(q);
|
2013-06-13 14:23:36 +08:00
|
|
|
else
|
|
|
|
ret = -EINVAL;
|
2013-06-06 07:54:39 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap_put_tap_dev(tap);
|
2013-06-06 07:54:39 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int set_offload(struct tap_queue *q, unsigned long arg)
|
2013-06-26 04:04:21 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2013-06-26 04:04:21 +08:00
|
|
|
netdev_features_t features;
|
|
|
|
netdev_features_t feature_mask = 0;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = rtnl_dereference(q->tap);
|
|
|
|
if (!tap)
|
2013-06-26 04:04:21 +08:00
|
|
|
return -ENOLINK;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
features = tap->dev->features;
|
2013-06-26 04:04:21 +08:00
|
|
|
|
|
|
|
if (arg & TUN_F_CSUM) {
|
|
|
|
feature_mask = NETIF_F_HW_CSUM;
|
|
|
|
|
|
|
|
if (arg & (TUN_F_TSO4 | TUN_F_TSO6)) {
|
|
|
|
if (arg & TUN_F_TSO_ECN)
|
|
|
|
feature_mask |= NETIF_F_TSO_ECN;
|
|
|
|
if (arg & TUN_F_TSO4)
|
|
|
|
feature_mask |= NETIF_F_TSO;
|
|
|
|
if (arg & TUN_F_TSO6)
|
|
|
|
feature_mask |= NETIF_F_TSO6;
|
|
|
|
}
|
2022-12-07 19:35:55 +08:00
|
|
|
|
|
|
|
/* TODO: for now USO4 and USO6 should work simultaneously */
|
|
|
|
if ((arg & (TUN_F_USO4 | TUN_F_USO6)) == (TUN_F_USO4 | TUN_F_USO6))
|
|
|
|
features |= NETIF_F_GSO_UDP_L4;
|
2013-06-26 04:04:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* tun/tap driver inverts the usage for TSO offloads, where
|
|
|
|
* setting the TSO bit means that the userspace wants to
|
|
|
|
* accept TSO frames and turning it off means that user space
|
|
|
|
* does not support TSO.
|
2017-02-11 08:03:47 +08:00
|
|
|
* For tap, we have to invert it to mean the same thing.
|
2013-06-26 04:04:21 +08:00
|
|
|
* When user space turns off TSO, we turn off GSO/LRO so that
|
|
|
|
* user-space will not receive TSO frames.
|
|
|
|
*/
|
2022-12-07 19:35:55 +08:00
|
|
|
if (feature_mask & (NETIF_F_TSO | NETIF_F_TSO6) ||
|
|
|
|
(feature_mask & (TUN_F_USO4 | TUN_F_USO6)) == (TUN_F_USO4 | TUN_F_USO6))
|
2013-06-26 04:04:21 +08:00
|
|
|
features |= RX_OFFLOADS;
|
|
|
|
else
|
|
|
|
features &= ~RX_OFFLOADS;
|
|
|
|
|
|
|
|
/* tap_features are the same as features on tun/tap and
|
|
|
|
* reflect user expectations.
|
|
|
|
*/
|
2017-02-11 08:03:49 +08:00
|
|
|
tap->tap_features = feature_mask;
|
|
|
|
if (tap->update_features)
|
|
|
|
tap->update_features(tap, features);
|
2013-06-26 04:04:21 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
/*
|
|
|
|
* provide compatibility with generic tun/tap interface
|
|
|
|
*/
|
2017-02-11 08:03:47 +08:00
|
|
|
static long tap_ioctl(struct file *file, unsigned int cmd,
|
|
|
|
unsigned long arg)
|
2010-01-30 20:24:26 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = file->private_data;
|
2017-02-11 08:03:49 +08:00
|
|
|
struct tap_dev *tap;
|
2010-01-30 20:24:26 +08:00
|
|
|
void __user *argp = (void __user *)arg;
|
|
|
|
struct ifreq __user *ifr = argp;
|
|
|
|
unsigned int __user *up = argp;
|
2014-12-16 21:04:56 +08:00
|
|
|
unsigned short u;
|
2010-04-29 18:50:48 +08:00
|
|
|
int __user *sp = argp;
|
2015-05-14 02:19:02 +08:00
|
|
|
struct sockaddr sa;
|
2010-04-29 18:50:48 +08:00
|
|
|
int s;
|
2010-02-18 13:45:36 +08:00
|
|
|
int ret;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
switch (cmd) {
|
|
|
|
case TUNSETIFF:
|
|
|
|
/* ignore the name, just look at flags */
|
|
|
|
if (get_user(u, &ifr->ifr_flags))
|
|
|
|
return -EFAULT;
|
2010-02-18 13:48:17 +08:00
|
|
|
|
|
|
|
ret = 0;
|
2017-02-11 08:03:47 +08:00
|
|
|
if ((u & ~TAP_IFFEATURES) != (IFF_NO_PI | IFF_TAP))
|
2010-02-18 13:48:17 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
else
|
2017-02-11 08:03:47 +08:00
|
|
|
q->flags = (q->flags & ~TAP_IFFEATURES) | u;
|
2010-02-18 13:48:17 +08:00
|
|
|
|
|
|
|
return ret;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
|
|
|
case TUNGETIFF:
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_lock();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = tap_get_tap_dev(q);
|
|
|
|
if (!tap) {
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_unlock();
|
2010-01-30 20:24:26 +08:00
|
|
|
return -ENOLINK;
|
2013-06-26 04:04:19 +08:00
|
|
|
}
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2010-02-18 13:45:36 +08:00
|
|
|
ret = 0;
|
2014-12-16 21:04:56 +08:00
|
|
|
u = q->flags;
|
2017-02-11 08:03:49 +08:00
|
|
|
if (copy_to_user(&ifr->ifr_name, tap->dev->name, IFNAMSIZ) ||
|
2014-12-16 21:04:56 +08:00
|
|
|
put_user(u, &ifr->ifr_flags))
|
2010-02-18 13:45:36 +08:00
|
|
|
ret = -EFAULT;
|
2017-02-11 08:03:49 +08:00
|
|
|
tap_put_tap_dev(tap);
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_unlock();
|
2010-02-18 13:45:36 +08:00
|
|
|
return ret;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2013-06-06 07:54:39 +08:00
|
|
|
case TUNSETQUEUE:
|
|
|
|
if (get_user(u, &ifr->ifr_flags))
|
|
|
|
return -EFAULT;
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_lock();
|
2017-02-11 08:03:47 +08:00
|
|
|
ret = tap_ioctl_set_queue(file, u);
|
2013-06-26 04:04:19 +08:00
|
|
|
rtnl_unlock();
|
2013-07-16 13:36:33 +08:00
|
|
|
return ret;
|
2013-06-06 07:54:39 +08:00
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
case TUNGETFEATURES:
|
2017-02-11 08:03:47 +08:00
|
|
|
if (put_user(IFF_TAP | IFF_NO_PI | TAP_IFFEATURES, up))
|
2010-01-30 20:24:26 +08:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case TUNSETSNDBUF:
|
2015-09-18 18:41:09 +08:00
|
|
|
if (get_user(s, sp))
|
2010-01-30 20:24:26 +08:00
|
|
|
return -EFAULT;
|
2017-10-31 06:50:11 +08:00
|
|
|
if (s <= 0)
|
|
|
|
return -EINVAL;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2015-09-18 18:41:09 +08:00
|
|
|
q->sk.sk_sndbuf = s;
|
2010-01-30 20:24:26 +08:00
|
|
|
return 0;
|
|
|
|
|
2010-04-29 18:50:48 +08:00
|
|
|
case TUNGETVNETHDRSZ:
|
|
|
|
s = q->vnet_hdr_sz;
|
|
|
|
if (put_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case TUNSETVNETHDRSZ:
|
|
|
|
if (get_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
if (s < (int)sizeof(struct virtio_net_hdr))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
q->vnet_hdr_sz = s;
|
|
|
|
return 0;
|
|
|
|
|
2014-12-16 21:05:10 +08:00
|
|
|
case TUNGETVNETLE:
|
2017-02-11 08:03:47 +08:00
|
|
|
s = !!(q->flags & TAP_VNET_LE);
|
2014-12-16 21:05:10 +08:00
|
|
|
if (put_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case TUNSETVNETLE:
|
|
|
|
if (get_user(s, sp))
|
|
|
|
return -EFAULT;
|
|
|
|
if (s)
|
2017-02-11 08:03:47 +08:00
|
|
|
q->flags |= TAP_VNET_LE;
|
2014-12-16 21:05:10 +08:00
|
|
|
else
|
2017-02-11 08:03:47 +08:00
|
|
|
q->flags &= ~TAP_VNET_LE;
|
2014-12-16 21:05:10 +08:00
|
|
|
return 0;
|
|
|
|
|
2015-04-24 20:50:36 +08:00
|
|
|
case TUNGETVNETBE:
|
2017-02-11 08:03:47 +08:00
|
|
|
return tap_get_vnet_be(q, sp);
|
2015-04-24 20:50:36 +08:00
|
|
|
|
|
|
|
case TUNSETVNETBE:
|
2017-02-11 08:03:47 +08:00
|
|
|
return tap_set_vnet_be(q, sp);
|
2015-04-24 20:50:36 +08:00
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
case TUNSETOFFLOAD:
|
|
|
|
/* let the user check for future flags */
|
|
|
|
if (arg & ~(TUN_F_CSUM | TUN_F_TSO4 | TUN_F_TSO6 |
|
2022-12-07 19:35:55 +08:00
|
|
|
TUN_F_TSO_ECN | TUN_F_UFO |
|
|
|
|
TUN_F_USO4 | TUN_F_USO6))
|
2010-01-30 20:24:26 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2013-06-26 04:04:21 +08:00
|
|
|
rtnl_lock();
|
|
|
|
ret = set_offload(q, arg);
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
2010-01-30 20:24:26 +08:00
|
|
|
|
2015-05-12 03:00:10 +08:00
|
|
|
case SIOCGIFHWADDR:
|
|
|
|
rtnl_lock();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = tap_get_tap_dev(q);
|
|
|
|
if (!tap) {
|
2015-05-12 03:00:10 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return -ENOLINK;
|
|
|
|
}
|
|
|
|
ret = 0;
|
net: fix dev_ifsioc_locked() race condition
dev_ifsioc_locked() is called with only RCU read lock, so when
there is a parallel writer changing the mac address, it could
get a partially updated mac address, as shown below:
Thread 1 Thread 2
// eth_commit_mac_addr_change()
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
// dev_ifsioc_locked()
memcpy(ifr->ifr_hwaddr.sa_data,
dev->dev_addr,...);
Close this race condition by guarding them with a RW semaphore,
like netdev_get_name(). We can not use seqlock here as it does not
allow blocking. The writers already take RTNL anyway, so this does
not affect the slow path. To avoid bothering existing
dev_set_mac_address() callers in drivers, introduce a new wrapper
just for user-facing callers on ioctl and rtnetlink paths.
Note, bonding also changes slave mac addresses but that requires
a separate patch due to the complexity of bonding code.
Fixes: 3710becf8a58 ("net: RCU locking for simple ioctl()")
Reported-by: "Gong, Sishuai" <sishuai@purdue.edu>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Jakub Kicinski <kuba@kernel.org>
Signed-off-by: Cong Wang <cong.wang@bytedance.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-02-12 03:34:10 +08:00
|
|
|
dev_get_mac_address(&sa, dev_net(tap->dev), tap->dev->name);
|
2017-02-11 08:03:49 +08:00
|
|
|
if (copy_to_user(&ifr->ifr_name, tap->dev->name, IFNAMSIZ) ||
|
net: fix dev_ifsioc_locked() race condition
dev_ifsioc_locked() is called with only RCU read lock, so when
there is a parallel writer changing the mac address, it could
get a partially updated mac address, as shown below:
Thread 1 Thread 2
// eth_commit_mac_addr_change()
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
// dev_ifsioc_locked()
memcpy(ifr->ifr_hwaddr.sa_data,
dev->dev_addr,...);
Close this race condition by guarding them with a RW semaphore,
like netdev_get_name(). We can not use seqlock here as it does not
allow blocking. The writers already take RTNL anyway, so this does
not affect the slow path. To avoid bothering existing
dev_set_mac_address() callers in drivers, introduce a new wrapper
just for user-facing callers on ioctl and rtnetlink paths.
Note, bonding also changes slave mac addresses but that requires
a separate patch due to the complexity of bonding code.
Fixes: 3710becf8a58 ("net: RCU locking for simple ioctl()")
Reported-by: "Gong, Sishuai" <sishuai@purdue.edu>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Jakub Kicinski <kuba@kernel.org>
Signed-off-by: Cong Wang <cong.wang@bytedance.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-02-12 03:34:10 +08:00
|
|
|
copy_to_user(&ifr->ifr_hwaddr, &sa, sizeof(sa)))
|
2015-05-12 03:00:10 +08:00
|
|
|
ret = -EFAULT;
|
2017-02-11 08:03:49 +08:00
|
|
|
tap_put_tap_dev(tap);
|
2015-05-12 03:00:10 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
case SIOCSIFHWADDR:
|
2015-05-14 02:19:02 +08:00
|
|
|
if (copy_from_user(&sa, &ifr->ifr_hwaddr, sizeof(sa)))
|
|
|
|
return -EFAULT;
|
2015-05-12 03:00:10 +08:00
|
|
|
rtnl_lock();
|
2017-02-11 08:03:49 +08:00
|
|
|
tap = tap_get_tap_dev(q);
|
|
|
|
if (!tap) {
|
2015-05-12 03:00:10 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return -ENOLINK;
|
|
|
|
}
|
net: fix dev_ifsioc_locked() race condition
dev_ifsioc_locked() is called with only RCU read lock, so when
there is a parallel writer changing the mac address, it could
get a partially updated mac address, as shown below:
Thread 1 Thread 2
// eth_commit_mac_addr_change()
memcpy(dev->dev_addr, addr->sa_data, ETH_ALEN);
// dev_ifsioc_locked()
memcpy(ifr->ifr_hwaddr.sa_data,
dev->dev_addr,...);
Close this race condition by guarding them with a RW semaphore,
like netdev_get_name(). We can not use seqlock here as it does not
allow blocking. The writers already take RTNL anyway, so this does
not affect the slow path. To avoid bothering existing
dev_set_mac_address() callers in drivers, introduce a new wrapper
just for user-facing callers on ioctl and rtnetlink paths.
Note, bonding also changes slave mac addresses but that requires
a separate patch due to the complexity of bonding code.
Fixes: 3710becf8a58 ("net: RCU locking for simple ioctl()")
Reported-by: "Gong, Sishuai" <sishuai@purdue.edu>
Cc: Eric Dumazet <eric.dumazet@gmail.com>
Cc: Jakub Kicinski <kuba@kernel.org>
Signed-off-by: Cong Wang <cong.wang@bytedance.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2021-02-12 03:34:10 +08:00
|
|
|
ret = dev_set_mac_address_user(tap->dev, &sa, NULL);
|
2017-02-11 08:03:49 +08:00
|
|
|
tap_put_tap_dev(tap);
|
2015-05-12 03:00:10 +08:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
|
2010-01-30 20:24:26 +08:00
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-13 05:52:31 +08:00
|
|
|
static const struct file_operations tap_fops = {
|
2010-01-30 20:24:26 +08:00
|
|
|
.owner = THIS_MODULE,
|
2017-02-11 08:03:47 +08:00
|
|
|
.open = tap_open,
|
|
|
|
.release = tap_release,
|
|
|
|
.read_iter = tap_read_iter,
|
|
|
|
.write_iter = tap_write_iter,
|
|
|
|
.poll = tap_poll,
|
2010-01-30 20:24:26 +08:00
|
|
|
.llseek = no_llseek,
|
2017-02-11 08:03:47 +08:00
|
|
|
.unlocked_ioctl = tap_ioctl,
|
2018-09-11 23:23:00 +08:00
|
|
|
.compat_ioctl = compat_ptr_ioctl,
|
2010-01-30 20:24:26 +08:00
|
|
|
};
|
|
|
|
|
2018-09-12 11:17:08 +08:00
|
|
|
static int tap_get_user_xdp(struct tap_queue *q, struct xdp_buff *xdp)
|
|
|
|
{
|
|
|
|
struct tun_xdp_hdr *hdr = xdp->data_hard_start;
|
|
|
|
struct virtio_net_hdr *gso = &hdr->gso;
|
|
|
|
int buflen = hdr->buflen;
|
|
|
|
int vnet_hdr_len = 0;
|
|
|
|
struct tap_dev *tap;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int err, depth;
|
|
|
|
|
|
|
|
if (q->flags & IFF_VNET_HDR)
|
|
|
|
vnet_hdr_len = READ_ONCE(q->vnet_hdr_sz);
|
|
|
|
|
|
|
|
skb = build_skb(xdp->data_hard_start, buflen);
|
|
|
|
if (!skb) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb_reserve(skb, xdp->data - xdp->data_hard_start);
|
|
|
|
skb_put(skb, xdp->data_end - xdp->data);
|
|
|
|
|
|
|
|
skb_set_network_header(skb, ETH_HLEN);
|
|
|
|
skb_reset_mac_header(skb);
|
|
|
|
skb->protocol = eth_hdr(skb)->h_proto;
|
|
|
|
|
|
|
|
if (vnet_hdr_len) {
|
|
|
|
err = virtio_net_hdr_to_skb(skb, gso, tap_is_little_endian(q));
|
|
|
|
if (err)
|
|
|
|
goto err_kfree;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Move network header to the right position for VLAN tagged packets */
|
2021-01-15 10:32:38 +08:00
|
|
|
if (eth_type_vlan(skb->protocol) &&
|
2023-05-09 21:18:57 +08:00
|
|
|
vlan_get_protocol_and_depth(skb, skb->protocol, &depth) != 0)
|
2018-09-12 11:17:08 +08:00
|
|
|
skb_set_network_header(skb, depth);
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
tap = rcu_dereference(q->tap);
|
|
|
|
if (tap) {
|
|
|
|
skb->dev = tap->dev;
|
net: Don't set transport offset to invalid value
If the socket was created with socket(AF_PACKET, SOCK_RAW, 0),
skb->protocol will be unset, __skb_flow_dissect() will fail, and
skb_probe_transport_header() will fall back to the offset_hint, making
the resulting skb_transport_offset incorrect.
If, however, there is no transport header in the packet,
transport_header shouldn't be set to an arbitrary value.
Fix it by leaving the transport offset unset if it couldn't be found, to
be explicit rather than to fill it with some wrong value. It changes the
behavior, but if some code relied on the old behavior, it would be
broken anyway, as the old one is incorrect.
Signed-off-by: Maxim Mikityanskiy <maximmi@mellanox.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-02-21 20:39:57 +08:00
|
|
|
skb_probe_transport_header(skb);
|
2018-09-12 11:17:08 +08:00
|
|
|
dev_queue_xmit(skb);
|
|
|
|
} else {
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_kfree:
|
|
|
|
kfree_skb(skb);
|
|
|
|
err:
|
|
|
|
rcu_read_lock();
|
2019-09-27 17:40:39 +08:00
|
|
|
tap = rcu_dereference(q->tap);
|
2018-09-12 11:17:08 +08:00
|
|
|
if (tap && tap->count_tx_dropped)
|
|
|
|
tap->count_tx_dropped(tap);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_sendmsg(struct socket *sock, struct msghdr *m,
|
|
|
|
size_t total_len)
|
2010-02-18 13:46:50 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = container_of(sock, struct tap_queue, sock);
|
2018-09-12 11:17:06 +08:00
|
|
|
struct tun_msg_ctl *ctl = m->msg_control;
|
2018-09-12 11:17:08 +08:00
|
|
|
struct xdp_buff *xdp;
|
|
|
|
int i;
|
2018-09-12 11:17:06 +08:00
|
|
|
|
2022-03-03 10:24:40 +08:00
|
|
|
if (m->msg_controllen == sizeof(struct tun_msg_ctl) &&
|
|
|
|
ctl && ctl->type == TUN_MSG_PTR) {
|
2018-09-12 11:17:08 +08:00
|
|
|
for (i = 0; i < ctl->num; i++) {
|
|
|
|
xdp = &((struct xdp_buff *)ctl->ptr)[i];
|
|
|
|
tap_get_user_xdp(q, xdp);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2018-09-12 11:17:06 +08:00
|
|
|
|
|
|
|
return tap_get_user(q, ctl ? ctl->ptr : NULL, &m->msg_iter,
|
|
|
|
m->msg_flags & MSG_DONTWAIT);
|
2010-02-18 13:46:50 +08:00
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_recvmsg(struct socket *sock, struct msghdr *m,
|
|
|
|
size_t total_len, int flags)
|
2010-02-18 13:46:50 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = container_of(sock, struct tap_queue, sock);
|
2017-12-01 18:10:38 +08:00
|
|
|
struct sk_buff *skb = m->msg_control;
|
2010-02-18 13:46:50 +08:00
|
|
|
int ret;
|
2017-12-01 18:10:38 +08:00
|
|
|
if (flags & ~(MSG_DONTWAIT|MSG_TRUNC)) {
|
2018-09-20 17:37:41 +08:00
|
|
|
kfree_skb(skb);
|
2010-02-18 13:46:50 +08:00
|
|
|
return -EINVAL;
|
2017-12-01 18:10:38 +08:00
|
|
|
}
|
|
|
|
ret = tap_do_read(q, &m->msg_iter, flags & MSG_DONTWAIT, skb);
|
2013-12-11 11:06:18 +08:00
|
|
|
if (ret > total_len) {
|
|
|
|
m->msg_flags |= MSG_TRUNC;
|
|
|
|
ret = flags & MSG_TRUNC ? ret : total_len;
|
|
|
|
}
|
2010-02-18 13:46:50 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-02-11 08:03:47 +08:00
|
|
|
static int tap_peek_len(struct socket *sock)
|
2016-07-15 15:46:31 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q = container_of(sock, struct tap_queue,
|
2016-07-15 15:46:31 +08:00
|
|
|
sock);
|
2018-01-04 11:14:27 +08:00
|
|
|
return PTR_RING_PEEK_CALL(&q->ring, __skb_array_len_with_tag);
|
2016-07-15 15:46:31 +08:00
|
|
|
}
|
|
|
|
|
2010-02-18 13:46:50 +08:00
|
|
|
/* Ops structure to mimic raw sockets with tun */
|
2017-02-11 08:03:47 +08:00
|
|
|
static const struct proto_ops tap_socket_ops = {
|
|
|
|
.sendmsg = tap_sendmsg,
|
|
|
|
.recvmsg = tap_recvmsg,
|
|
|
|
.peek_len = tap_peek_len,
|
2010-02-18 13:46:50 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
/* Get an underlying socket object from tun file. Returns error unless file is
|
|
|
|
* attached to a device. The returned object works like a packet socket, it
|
|
|
|
* can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for
|
|
|
|
* holding a reference to the file for as long as the socket is in use. */
|
2017-02-11 08:03:47 +08:00
|
|
|
struct socket *tap_get_socket(struct file *file)
|
2010-02-18 13:46:50 +08:00
|
|
|
{
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q;
|
|
|
|
if (file->f_op != &tap_fops)
|
2010-02-18 13:46:50 +08:00
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
q = file->private_data;
|
|
|
|
if (!q)
|
|
|
|
return ERR_PTR(-EBADFD);
|
|
|
|
return &q->sock;
|
|
|
|
}
|
2017-02-11 08:03:47 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_get_socket);
|
2010-02-18 13:46:50 +08:00
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
struct ptr_ring *tap_get_ptr_ring(struct file *file)
|
2017-05-17 12:14:42 +08:00
|
|
|
{
|
|
|
|
struct tap_queue *q;
|
|
|
|
|
|
|
|
if (file->f_op != &tap_fops)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
q = file->private_data;
|
|
|
|
if (!q)
|
|
|
|
return ERR_PTR(-EBADFD);
|
2018-01-04 11:14:27 +08:00
|
|
|
return &q->ring;
|
2017-05-17 12:14:42 +08:00
|
|
|
}
|
2018-01-04 11:14:27 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_get_ptr_ring);
|
2017-05-17 12:14:42 +08:00
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
int tap_queue_resize(struct tap_dev *tap)
|
2016-07-15 15:46:31 +08:00
|
|
|
{
|
2017-02-11 08:03:49 +08:00
|
|
|
struct net_device *dev = tap->dev;
|
2017-02-11 08:03:47 +08:00
|
|
|
struct tap_queue *q;
|
2018-01-04 11:14:27 +08:00
|
|
|
struct ptr_ring **rings;
|
2017-02-11 08:03:49 +08:00
|
|
|
int n = tap->numqueues;
|
2016-07-15 15:46:31 +08:00
|
|
|
int ret, i = 0;
|
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
rings = kmalloc_array(n, sizeof(*rings), GFP_KERNEL);
|
|
|
|
if (!rings)
|
2016-07-15 15:46:31 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2017-02-11 08:03:49 +08:00
|
|
|
list_for_each_entry(q, &tap->queue_list, next)
|
2018-01-04 11:14:27 +08:00
|
|
|
rings[i++] = &q->ring;
|
2016-07-15 15:46:31 +08:00
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
ret = ptr_ring_resize_multiple(rings, n,
|
|
|
|
dev->tx_queue_len, GFP_KERNEL,
|
|
|
|
__skb_array_destroy_skb);
|
2016-07-15 15:46:31 +08:00
|
|
|
|
2018-01-04 11:14:27 +08:00
|
|
|
kfree(rings);
|
2016-07-15 15:46:31 +08:00
|
|
|
return ret;
|
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_queue_resize);
|
2017-02-11 08:03:48 +08:00
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
static int tap_list_add(dev_t major, const char *device_name)
|
|
|
|
{
|
|
|
|
struct major_info *tap_major;
|
|
|
|
|
|
|
|
tap_major = kzalloc(sizeof(*tap_major), GFP_ATOMIC);
|
|
|
|
if (!tap_major)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
tap_major->major = MAJOR(major);
|
|
|
|
|
|
|
|
idr_init(&tap_major->minor_idr);
|
2017-07-11 01:05:50 +08:00
|
|
|
spin_lock_init(&tap_major->minor_lock);
|
2017-02-11 08:03:50 +08:00
|
|
|
|
|
|
|
tap_major->device_name = device_name;
|
|
|
|
|
|
|
|
list_add_tail_rcu(&tap_major->next, &major_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-10-27 15:00:16 +08:00
|
|
|
int tap_create_cdev(struct cdev *tap_cdev, dev_t *tap_major,
|
|
|
|
const char *device_name, struct module *module)
|
2017-02-11 08:03:48 +08:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = alloc_chrdev_region(tap_major, 0, TAP_NUM_DEVS, device_name);
|
|
|
|
if (err)
|
|
|
|
goto out1;
|
|
|
|
|
|
|
|
cdev_init(tap_cdev, &tap_fops);
|
2017-10-27 15:00:16 +08:00
|
|
|
tap_cdev->owner = module;
|
2017-02-11 08:03:48 +08:00
|
|
|
err = cdev_add(tap_cdev, *tap_major, TAP_NUM_DEVS);
|
|
|
|
if (err)
|
|
|
|
goto out2;
|
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
err = tap_list_add(*tap_major, device_name);
|
|
|
|
if (err)
|
|
|
|
goto out3;
|
2017-02-11 08:03:48 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2017-02-11 08:03:50 +08:00
|
|
|
out3:
|
|
|
|
cdev_del(tap_cdev);
|
2017-02-11 08:03:48 +08:00
|
|
|
out2:
|
|
|
|
unregister_chrdev_region(*tap_major, TAP_NUM_DEVS);
|
|
|
|
out1:
|
|
|
|
return err;
|
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_create_cdev);
|
2017-02-11 08:03:48 +08:00
|
|
|
|
|
|
|
void tap_destroy_cdev(dev_t major, struct cdev *tap_cdev)
|
|
|
|
{
|
2017-02-11 08:03:50 +08:00
|
|
|
struct major_info *tap_major, *tmp;
|
|
|
|
|
2017-02-11 08:03:48 +08:00
|
|
|
cdev_del(tap_cdev);
|
|
|
|
unregister_chrdev_region(major, TAP_NUM_DEVS);
|
2017-02-11 08:03:50 +08:00
|
|
|
list_for_each_entry_safe(tap_major, tmp, &major_list, next) {
|
|
|
|
if (tap_major->major == MAJOR(major)) {
|
|
|
|
idr_destroy(&tap_major->minor_idr);
|
|
|
|
list_del_rcu(&tap_major->next);
|
|
|
|
kfree_rcu(tap_major, rcu);
|
|
|
|
}
|
|
|
|
}
|
2017-02-11 08:03:48 +08:00
|
|
|
}
|
2017-02-11 08:03:51 +08:00
|
|
|
EXPORT_SYMBOL_GPL(tap_destroy_cdev);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
|
|
|
|
MODULE_AUTHOR("Sainath Grandhi <sainath.grandhi@intel.com>");
|
|
|
|
MODULE_LICENSE("GPL");
|